{"version":3,"file":"5417-350b5928128122cf329e.js","mappings":"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","sources":["webpack://hyve/./node_modules/framer-motion/dist/es/components/MotionConfig/index.mjs","webpack://hyve/./node_modules/popmotion/dist/es/utils/is-point.mjs","webpack://hyve/./node_modules/popmotion/dist/es/utils/is-point-3d.mjs","webpack://hyve/./node_modules/popmotion/dist/es/utils/distance.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/gestures/PanSession.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/motion/features/drag.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/animation/animate.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","webpack://hyve/./node_modules/framer-motion/dist/es/render/dom/features-max.mjs"],"sourcesContent":["import { __rest, __assign } from 'tslib';\nimport * as React from 'react';\nimport { useContext, useMemo } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.mjs';\nimport { loadExternalIsValidProp } from '../../render/dom/utils/filter-props.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\n\n/**\n * `MotionConfig` is used to set configuration options for all children `motion` components.\n *\n * ```jsx\n * import { motion, MotionConfig } from \"framer-motion\"\n *\n * export function App() {\n *   return (\n *     <MotionConfig transition={{ type: \"spring\" }}>\n *       <motion.div animate={{ x: 100 }} />\n *     </MotionConfig>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction MotionConfig(_a) {\n    var children = _a.children, isValidProp = _a.isValidProp, config = __rest(_a, [\"children\", \"isValidProp\"]);\n    isValidProp && loadExternalIsValidProp(isValidProp);\n    /**\n     * Inherit props from any parent MotionConfig components\n     */\n    config = __assign(__assign({}, useContext(MotionConfigContext)), config);\n    /**\n     * Don't allow isStatic to change between renders as it affects how many hooks\n     * motion components fire.\n     */\n    config.isStatic = useConstant(function () { return config.isStatic; });\n    /**\n     * Creating a new config context object will re-render every `motion` component\n     * every time it renders. So we only want to create a new one sparingly.\n     */\n    var context = useMemo(function () { return config; }, [JSON.stringify(config.transition), config.transformPagePoint, config.reducedMotion]);\n    return (React.createElement(MotionConfigContext.Provider, { value: context }, children));\n}\n\nexport { MotionConfig };\n","const isPoint = (point) => point.hasOwnProperty('x') && point.hasOwnProperty('y');\n\nexport { isPoint };\n","import { isPoint } from './is-point.mjs';\n\nconst isPoint3D = (point) => isPoint(point) && point.hasOwnProperty('z');\n\nexport { isPoint3D };\n","import { isPoint } from './is-point.mjs';\nimport { isPoint3D } from './is-point-3d.mjs';\nimport { isNum } from './inc.mjs';\n\nconst distance1D = (a, b) => Math.abs(a - b);\nfunction distance(a, b) {\n    if (isNum(a) && isNum(b)) {\n        return distance1D(a, b);\n    }\n    else if (isPoint(a) && isPoint(b)) {\n        const xDelta = distance1D(a.x, b.x);\n        const yDelta = distance1D(a.y, b.y);\n        const zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\n        return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\n    }\n}\n\nexport { distance };\n","import { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\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 { mix, distance } from 'popmotion';\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return distance(value, target) < maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))\n        delta.scale = 1;\n    delta.translate =\n        mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate) || isNaN(delta.translate))\n        delta.translate = 0;\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","import { __read } from 'tslib';\nimport { clamp, mix, progress } from 'popmotion';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\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 * 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 { min: min, max: max };\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 a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clamp(0, 1, origin);\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 === void 0) { dragElastic = defaultElastic; }\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, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","var createAxisDelta = function () { return ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n}); };\nvar createDelta = function () { return ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n}); };\nvar createAxis = function () { return ({ min: 0, max: 0 }); };\nvar createBox = function () { return ({\n    x: createAxis(),\n    y: createAxis(),\n}); };\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\n","import { __assign } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/use-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\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        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\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;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\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            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\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                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_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            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!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.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\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 (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\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        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, 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(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\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            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\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, 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.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\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     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.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.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\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            return _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return __assign(__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\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 { useDrag } from '../../gestures/drag/use-drag.mjs';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\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.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { PanSession } from './PanSession.mjs';\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @privateRemarks\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 { useEffect } from 'react';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\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 dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\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, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\nexport { useDrag };\n","import { px } from 'style-value-types';\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\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 */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\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, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\n","import { mix } from 'popmotion';\nimport { complex } from 'style-value-types';\nimport { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\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 = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.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    },\n};\n\nexport { correctBoxShadow };\n","import { __extends, __assign, __read } from 'tslib';\nimport sync from 'framesync';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/state.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    __extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(__assign(__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync.postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default.Component));\nfunction MeasureLayout(props) {\n    var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, __assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: __assign(__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { MeasureLayout } from './MeasureLayout.mjs';\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\n","import { mix, progress, linear, circOut } from 'popmotion';\nimport { px, percent } from 'style-value-types';\n\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nvar asNumber = function (value) {\n    return typeof value === \"string\" ? parseFloat(value) : value;\n};\nvar isPx = function (value) {\n    return typeof value === \"number\" || px.test(value);\n};\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = mix(0, \n        // (follow?.opacity as number) ?? 0,\n        // TODO Reinstate this if only child\n        (_a = lead.opacity) !== null && _a !== void 0 ? _a : 1, easeCrossfadeIn(progress));\n        target.opacityExit = mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = mix((_c = follow.opacity) !== null && _c !== void 0 ? _c : 1, (_d = lead.opacity) !== null && _d !== void 0 ? _d : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\".concat(borders[i], \"Radius\");\n        var followRadius = getRadius(follow, borderLabel);\n        var leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        var canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (percent.test(leadRadius) || percent.test(followRadius)) {\n                target[borderLabel] += \"%\";\n            }\n        }\n        else {\n            target[borderLabel] = leadRadius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (follow.rotate || lead.rotate) {\n        target.rotate = mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nvar easeCrossfadeIn = compress(0, 0.5, circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, linear);\nfunction compress(min, max, easing) {\n    return function (p) {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(progress(min, max, p));\n    };\n}\n\nexport { mixValues };\n","/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisInto(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyBoxInto(box, originBox) {\n    copyAxisInto(box.x, originBox.x);\n    copyAxisInto(box.y, originBox.y);\n}\n\nexport { copyAxisInto, copyBoxInto };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { scalePoint } from './delta-apply.mjs';\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate, scale, origin, boxScale, originAxis, sourceAxis) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    if (originAxis === void 0) { originAxis = axis; }\n    if (sourceAxis === void 0) { sourceAxis = axis; }\n    if (percent.test(translate)) {\n        translate = parseFloat(translate);\n        var relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    var originPoint = mix(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, _a, origin, sourceAxis) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","function isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction boxEquals(a, b) {\n    return (a.x.min === b.x.min &&\n        a.x.max === b.x.max &&\n        a.y.min === b.y.min &&\n        a.y.max === b.y.max);\n}\n\nexport { boxEquals, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\n\nvar NodeStack = /** @class */ (function () {\n    function NodeStack() {\n        this.members = [];\n    }\n    NodeStack.prototype.add = function (node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    };\n    NodeStack.prototype.remove = function (node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            var prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    };\n    NodeStack.prototype.relegate = function (node) {\n        var indexOfNode = this.members.findIndex(function (member) { return node === member; });\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        var prevLead;\n        for (var i = indexOfNode; i >= 0; i--) {\n            var member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    NodeStack.prototype.promote = function (node, preserveFollowOpacity) {\n        var _a;\n        var prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n                node.snapshot.isShared = true;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            var crossfade = node.options.crossfade;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    };\n    NodeStack.prototype.exitAnimationComplete = function () {\n        this.members.forEach(function (node) {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    };\n    NodeStack.prototype.scheduleRender = function () {\n        this.members.forEach(function (node) {\n            node.instance && node.scheduleRender(false);\n        });\n    };\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    NodeStack.prototype.removeLeadSnapshot = function () {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    };\n    return NodeStack;\n}());\n\nexport { NodeStack };\n","var identityProjection = \"translate3d(0px, 0px, 0) scale(1, 1) scale(1, 1)\";\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = delta.x.translate / treeScale.x;\n    var yTranslate = delta.y.translate / treeScale.y;\n    var transform = \"translate3d(\".concat(xTranslate, \"px, \").concat(yTranslate, \"px, 0) \");\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    transform += \"scale(\".concat(1 / treeScale.x, \", \").concat(1 / treeScale.y, \") \");\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\".concat(rotate, \"deg) \");\n        if (rotateX)\n            transform += \"rotateX(\".concat(rotateX, \"deg) \");\n        if (rotateY)\n            transform += \"rotateY(\".concat(rotateY, \"deg) \");\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    var elementScaleX = delta.x.scale * treeScale.x;\n    var elementScaleY = delta.y.scale * treeScale.y;\n    transform += \"scale(\".concat(elementScaleX, \", \").concat(elementScaleY, \")\");\n    return transform === identityProjection ? \"none\" : transform;\n}\n\nexport { buildProjectionTransform, identityProjection };\n","var compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nvar FlatTree = /** @class */ (function () {\n    function FlatTree() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    FlatTree.prototype.add = function (child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.remove = function (child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.forEach = function (callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    };\n    return FlatTree;\n}());\n\nexport { FlatTree };\n","import { __spreadArray, __read, __assign } from 'tslib';\nimport sync, { cancelSync, flushSync } from 'framesync';\nimport { mix } from 'popmotion';\nimport { animate } from '../../animation/animate.mjs';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\nimport { mixValues } from '../animation/mix-values.mjs';\nimport { copyBoxInto } from '../geometry/copy.mjs';\nimport { translateAxis, transformBox, applyBoxDelta, applyTreeDeltas } from '../geometry/delta-apply.mjs';\nimport { calcRelativePosition, calcRelativeBox, calcBoxDelta, calcLength } from '../geometry/delta-calc.mjs';\nimport { removeBoxTransforms } from '../geometry/delta-remove.mjs';\nimport { createBox, createDelta } from '../geometry/models.mjs';\nimport { getValueTransition } from '../../animation/utils/transitions.mjs';\nimport { boxEquals, isDeltaZero } from '../geometry/utils.mjs';\nimport { NodeStack } from '../shared/stack.mjs';\nimport { scaleCorrectors } from '../styles/scale-correction.mjs';\nimport { buildProjectionTransform } from '../styles/transform.mjs';\nimport { eachAxis } from '../utils/each-axis.mjs';\nimport { hasTransform, hasScale } from '../utils/has-transform.mjs';\nimport { transformAxes } from '../../render/html/utils/transform.mjs';\nimport { FlatTree } from '../../render/utils/flat-tree.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { globalProjectionState } from './state.mjs';\n\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nvar animationTarget = 1000;\nfunction createProjectionNode(_a) {\n    var attachResizeListener = _a.attachResizeListener, defaultParent = _a.defaultParent, measureScroll = _a.measureScroll, checkIsScrollRoot = _a.checkIsScrollRoot, resetTransform = _a.resetTransform;\n    return /** @class */ (function () {\n        function ProjectionNode(id, latestValues, parent) {\n            var _this = this;\n            if (latestValues === void 0) { latestValues = {}; }\n            if (parent === void 0) { parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent(); }\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to actually\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = function () {\n                if (_this.isUpdating) {\n                    _this.isUpdating = false;\n                    _this.clearAllSnapshots();\n                }\n            };\n            this.updateProjection = function () {\n                _this.nodes.forEach(resolveTargetDelta);\n                _this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.id = id;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? __spreadArray(__spreadArray([], __read(parent.path), false), [parent], false) : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            id && this.root.registerPotentialNode(id, this);\n            for (var i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        ProjectionNode.prototype.addEventListener = function (name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        };\n        ProjectionNode.prototype.notifyListeners = function (name) {\n            var args = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                args[_i - 1] = arguments[_i];\n            }\n            var subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify.apply(subscriptionManager, __spreadArray([], __read(args), false));\n        };\n        ProjectionNode.prototype.hasListeners = function (name) {\n            return this.eventHandlers.has(name);\n        };\n        ProjectionNode.prototype.registerPotentialNode = function (id, node) {\n            this.potentialNodes.set(id, node);\n        };\n        /**\n         * Lifecycles\n         */\n        ProjectionNode.prototype.mount = function (instance, isLayoutDirty) {\n            var _this = this;\n            var _a;\n            if (isLayoutDirty === void 0) { isLayoutDirty = false; }\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            var _b = this.options, layoutId = _b.layoutId, layout = _b.layout, visualElement = _b.visualElement;\n            if (visualElement && !visualElement.getInstance()) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.id && this.root.potentialNodes.delete(this.id);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                var unblockTimeout_1;\n                var resizeUnblockUpdate_1 = function () {\n                    return (_this.root.updateBlockedByResize = false);\n                };\n                attachResizeListener(instance, function () {\n                    _this.root.updateBlockedByResize = true;\n                    clearTimeout(unblockTimeout_1);\n                    unblockTimeout_1 = window.setTimeout(resizeUnblockUpdate_1, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        _this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", function (_a) {\n                    var _b, _c, _d, _e, _f;\n                    var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged, hasRelativeTargetChanged = _a.hasRelativeTargetChanged, newLayout = _a.layout;\n                    if (_this.isTreeAnimationBlocked()) {\n                        _this.target = undefined;\n                        _this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    var layoutTransition = (_c = (_b = _this.options.transition) !== null && _b !== void 0 ? _b : visualElement.getDefaultTransition()) !== null && _c !== void 0 ? _c : defaultLayoutTransition;\n                    var _g = visualElement.getProps(), onLayoutAnimationStart = _g.onLayoutAnimationStart, onLayoutAnimationComplete = _g.onLayoutAnimationComplete;\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    var targetChanged = !_this.targetLayout ||\n                        !boxEquals(_this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    var hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_d = _this.resumeFrom) === null || _d === void 0 ? void 0 : _d.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !_this.currentAnimation))) {\n                        if (_this.resumeFrom) {\n                            _this.resumingFrom = _this.resumeFrom;\n                            _this.resumingFrom.resumingFrom = undefined;\n                        }\n                        _this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        var animationOptions = __assign(__assign({}, getValueTransition(layoutTransition, \"layout\")), { onPlay: onLayoutAnimationStart, onComplete: onLayoutAnimationComplete });\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        _this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            _this.animationProgress === 0) {\n                            _this.finishAnimation();\n                        }\n                        _this.isLead() && ((_f = (_e = _this.options).onExitComplete) === null || _f === void 0 ? void 0 : _f.call(_e));\n                    }\n                    _this.targetLayout = newLayout;\n                });\n            }\n        };\n        ProjectionNode.prototype.unmount = function () {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            cancelSync.preRender(this.updateProjection);\n        };\n        // only on the root\n        ProjectionNode.prototype.blockUpdate = function () {\n            this.updateManuallyBlocked = true;\n        };\n        ProjectionNode.prototype.unblockUpdate = function () {\n            this.updateManuallyBlocked = false;\n        };\n        ProjectionNode.prototype.isUpdateBlocked = function () {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        };\n        ProjectionNode.prototype.isTreeAnimationBlocked = function () {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        };\n        // Note: currently only running on root node\n        ProjectionNode.prototype.startUpdate = function () {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n        };\n        ProjectionNode.prototype.willUpdate = function (shouldNotifyListeners) {\n            var _a, _b, _c;\n            if (shouldNotifyListeners === void 0) { shouldNotifyListeners = true; }\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                node.shouldResetTransform = true;\n                /**\n                 * TODO: Check we haven't updated the scroll\n                 * since the last didUpdate\n                 */\n                node.updateScroll();\n            }\n            var _d = this.options, layoutId = _d.layoutId, layout = _d.layout;\n            if (layoutId === undefined && !layout)\n                return;\n            var transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        };\n        // Note: Currently only running on root node\n        ProjectionNode.prototype.didUpdate = function () {\n            var updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            flushSync.update();\n            flushSync.preRender();\n            flushSync.render();\n        };\n        ProjectionNode.prototype.clearAllSnapshots = function () {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        };\n        ProjectionNode.prototype.scheduleUpdateProjection = function () {\n            sync.preRender(this.updateProjection, false, true);\n        };\n        ProjectionNode.prototype.scheduleCheckAfterUnmount = function () {\n            var _this = this;\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync.postRender(function () {\n                if (_this.isLayoutDirty) {\n                    _this.root.didUpdate();\n                }\n                else {\n                    _this.root.checkUpdateFailed();\n                }\n            });\n        };\n        /**\n         * Update measurements\n         */\n        ProjectionNode.prototype.updateSnapshot = function () {\n            if (this.snapshot || !this.instance)\n                return;\n            var measured = this.measure();\n            var layout = this.removeTransform(this.removeElementScroll(measured));\n            roundBox(layout);\n            this.snapshot = {\n                measured: measured,\n                layout: layout,\n                latestValues: {},\n            };\n        };\n        ProjectionNode.prototype.updateLayout = function () {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (var i = 0; i < this.path.length; i++) {\n                    var node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            var measured = this.measure();\n            roundBox(measured);\n            var prevLayout = this.layout;\n            this.layout = {\n                measured: measured,\n                actual: this.removeElementScroll(measured),\n            };\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.actual);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notifyLayoutMeasure(this.layout.actual, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.actual);\n        };\n        ProjectionNode.prototype.updateScroll = function () {\n            if (this.options.layoutScroll && this.instance) {\n                this.isScrollRoot = checkIsScrollRoot(this.instance);\n                this.scroll = measureScroll(this.instance);\n            }\n        };\n        ProjectionNode.prototype.resetTransform = function () {\n            var _a;\n            if (!resetTransform)\n                return;\n            var isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            var hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            var transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            var transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        };\n        ProjectionNode.prototype.measure = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return createBox();\n            var box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            var scroll = this.root.scroll;\n            if (scroll) {\n                translateAxis(box.x, scroll.x);\n                translateAxis(box.y, scroll.y);\n            }\n            return box;\n        };\n        ProjectionNode.prototype.removeElementScroll = function (box) {\n            var boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                var scroll_1 = node.scroll, options = node.options, isScrollRoot = node.isScrollRoot;\n                if (node !== this.root && scroll_1 && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (isScrollRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        var rootScroll = this.root.scroll;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll_1.x);\n                    translateAxis(boxWithoutScroll.y, scroll_1.y);\n                }\n            }\n            return boxWithoutScroll;\n        };\n        ProjectionNode.prototype.applyTransform = function (box, transformOnly) {\n            if (transformOnly === void 0) { transformOnly = false; }\n            var withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.x,\n                        y: -node.scroll.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        };\n        ProjectionNode.prototype.removeTransform = function (box) {\n            var _a;\n            var boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                var sourceBox = createBox();\n                var nodeBox = node.measure();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layout, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        };\n        /**\n         *\n         */\n        ProjectionNode.prototype.setTargetDelta = function (delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n        };\n        ProjectionNode.prototype.setOptions = function (options) {\n            var _a;\n            this.options = __assign(__assign(__assign({}, this.options), options), { crossfade: (_a = options.crossfade) !== null && _a !== void 0 ? _a : true });\n        };\n        ProjectionNode.prototype.clearMeasurements = function () {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        };\n        /**\n         * Frame calculations\n         */\n        ProjectionNode.prototype.resolveTargetDelta = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent && this.relativeParent.layout) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.actual, this.relativeParent.layout.actual);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.actual);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.actual);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.actual);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent &&\n                    Boolean(this.relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !this.relativeParent.options.layoutScroll &&\n                    this.relativeParent.target) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, this.relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n        };\n        ProjectionNode.prototype.getClosestProjectingParent = function () {\n            if (!this.parent || hasTransform(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        };\n        ProjectionNode.prototype.calcProjection = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            var lead = this.getLead();\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.actual);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, Boolean(this.resumingFrom) || this !== lead);\n            var target = lead.target;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            var prevTreeScaleX = this.treeScale.x;\n            var prevTreeScaleY = this.treeScale.y;\n            var prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        };\n        ProjectionNode.prototype.hide = function () {\n            this.isVisible = false;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.show = function () {\n            this.isVisible = true;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.scheduleRender = function (notifyAll) {\n            var _a, _b, _c;\n            if (notifyAll === void 0) { notifyAll = true; }\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        };\n        ProjectionNode.prototype.setAnimationOrigin = function (delta, hasOnlyRelativeTargetChanged) {\n            var _this = this;\n            var _a;\n            if (hasOnlyRelativeTargetChanged === void 0) { hasOnlyRelativeTargetChanged = false; }\n            var snapshot = this.snapshot;\n            var snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            var mixedValues = __assign({}, this.latestValues);\n            var targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            var relativeLayout = createBox();\n            var isSharedLayoutAnimation = snapshot === null || snapshot === void 0 ? void 0 : snapshot.isShared;\n            var isOnlyMember = (((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.members.length) || 0) <= 1;\n            var shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = function (latest) {\n                var _a;\n                var progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                _this.setTargetDelta(targetDelta);\n                if (_this.relativeTarget &&\n                    _this.relativeTargetOrigin &&\n                    _this.layout &&\n                    ((_a = _this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, _this.layout.actual, _this.relativeParent.layout.actual);\n                    mixBox(_this.relativeTarget, _this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    _this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, _this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                _this.root.scheduleUpdateProjection();\n                _this.scheduleRender();\n                _this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        };\n        ProjectionNode.prototype.startAnimation = function (options) {\n            var _this = this;\n            var _a, _b;\n            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                cancelSync.update(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = sync.update(function () {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                _this.currentAnimation = animate(0, animationTarget, __assign(__assign({}, options), { onUpdate: function (latest) {\n                        var _a;\n                        _this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    }, onComplete: function () {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        _this.completeAnimation();\n                    } }));\n                if (_this.resumingFrom) {\n                    _this.resumingFrom.currentAnimation = _this.currentAnimation;\n                }\n                _this.pendingAnimation = undefined;\n            });\n        };\n        ProjectionNode.prototype.completeAnimation = function () {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        };\n        ProjectionNode.prototype.finishAnimation = function () {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        };\n        ProjectionNode.prototype.applyTransformsToTarget = function () {\n            var _a = this.getLead(), targetWithTransforms = _a.targetWithTransforms, target = _a.target, layout = _a.layout, latestValues = _a.latestValues;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its actual layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        };\n        ProjectionNode.prototype.registerSharedNode = function (layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            var stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        };\n        ProjectionNode.prototype.isLead = function () {\n            var stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        };\n        ProjectionNode.prototype.getLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        };\n        ProjectionNode.prototype.getPrevLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        };\n        ProjectionNode.prototype.getStack = function () {\n            var layoutId = this.options.layoutId;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        };\n        ProjectionNode.prototype.promote = function (_a) {\n            var _b = _a === void 0 ? {} : _a, needsReset = _b.needsReset, transition = _b.transition, preserveFollowOpacity = _b.preserveFollowOpacity;\n            var stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition: transition });\n        };\n        ProjectionNode.prototype.relegate = function () {\n            var stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        };\n        ProjectionNode.prototype.resetRotation = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            var hasRotate = false;\n            // Keep a record of all the values we've reset\n            var resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (var i = 0; i < transformAxes.length; i++) {\n                var axis = transformAxes[i];\n                var key = \"rotate\" + axis;\n                // If this rotation doesn't exist as a motion value, then we don't\n                // need to reset it\n                if (!visualElement.getStaticValue(key)) {\n                    continue;\n                }\n                hasRotate = true;\n                // Record the rotation and then temporarily set it to 0\n                resetValues[key] = visualElement.getStaticValue(key);\n                visualElement.setStaticValue(key, 0);\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n            // Put back all the values we reset\n            for (var key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        };\n        ProjectionNode.prototype.getProjectionStyles = function (styleProp) {\n            var _a, _b, _c, _d, _e, _f;\n            if (styleProp === void 0) { styleProp = {}; }\n            // TODO: Return lifecycle-persistent object\n            var styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            var lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                var emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity = (_b = this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            var valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            var _g = this.projectionDelta, x = _g.x, y = _g.y;\n            styles.transformOrigin = \"\".concat(x.origin * 100, \"% \").concat(y.origin * 100, \"% 0\");\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_d = (_c = valuesToRender.opacity) !== null && _c !== void 0 ? _c : this.latestValues.opacity) !== null && _d !== void 0 ? _d : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its actual\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_e = valuesToRender.opacity) !== null && _e !== void 0 ? _e : \"\"\n                        : (_f = valuesToRender.opacityExit) !== null && _f !== void 0 ? _f : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (var key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                var _h = scaleCorrectors[key], correct = _h.correct, applyTo = _h.applyTo;\n                var corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        };\n        ProjectionNode.prototype.clearSnapshot = function () {\n            this.resumeFrom = this.snapshot = undefined;\n        };\n        // Only run on root\n        ProjectionNode.prototype.resetTree = function () {\n            this.root.nodes.forEach(function (node) { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        };\n        return ProjectionNode;\n    }());\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c, _d;\n    var snapshot = (_b = (_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) !== null && _b !== void 0 ? _b : node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        var _e = node.layout, layout_1 = _e.actual, measuredLayout = _e.measured;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (node.options.animationType === \"size\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout_1[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (node.options.animationType === \"position\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(layout_1[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        var layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout_1, snapshot.layout);\n        var visualDelta = createDelta();\n        if (snapshot.isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measured);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout_1, snapshot.layout);\n        }\n        var hasLayoutChanged = !isDeltaZero(layoutDelta);\n        var hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            node.relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (node.relativeParent && !node.relativeParent.resumeFrom) {\n                var _f = node.relativeParent, parentSnapshot = _f.snapshot, parentLayout = _f.layout;\n                if (parentSnapshot && parentLayout) {\n                    var relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layout, parentSnapshot.layout);\n                    var relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout_1, parentLayout.actual);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout: layout_1,\n            snapshot: snapshot,\n            delta: visualDelta,\n            layoutDelta: layoutDelta,\n            hasLayoutChanged: hasLayoutChanged,\n            hasRelativeTargetChanged: hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_d = (_c = node.options).onExitComplete) === null || _d === void 0 ? void 0 : _d.call(_c);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    var visualElement = node.options.visualElement;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notifyBeforeLayoutMeasure();\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = mix(delta.translate, 0, p);\n    output.scale = mix(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = mix(from.min, to.min, p);\n    output.max = mix(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, id) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    var searchNode = node.root;\n    for (var i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    var searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    var element = searchElement.querySelector(\"[data-projection-id=\\\"\".concat(id, \"\\\"]\"));\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\n\nexport { createProjectionNode, mixAxis, mixAxisDelta, mixBox };\n","import { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { startAnimation } from './utils/transitions.mjs';\n\n/**\n * Animate a single value or a `MotionValue`.\n *\n * The first argument is either a `MotionValue` to animate, or an initial animation value.\n *\n * The second is either a value to animate to, or an array of keyframes to animate through.\n *\n * The third argument can be either tween or spring options, and optional lifecycle methods: `onUpdate`, `onPlay`, `onComplete`, `onRepeat` and `onStop`.\n *\n * Returns `AnimationPlaybackControls`, currently just a `stop` method.\n *\n * ```javascript\n * const x = useMotionValue(0)\n *\n * useEffect(() => {\n *   const controls = animate(x, 100, {\n *     type: \"spring\",\n *     stiffness: 2000,\n *     onComplete: v => {}\n *   })\n *\n *   return controls.stop\n * })\n * ```\n *\n * @public\n */\nfunction animate(from, to, transition) {\n    if (transition === void 0) { transition = {}; }\n    var value = isMotionValue(from) ? from : motionValue(from);\n    startAnimation(\"\", value, to, transition);\n    return {\n        stop: function () { return value.stop(); },\n        isAnimating: function () { return value.isAnimating(); },\n    };\n}\n\nexport { animate };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) { return addDomEvent(ref, \"resize\", notify); },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n    checkIsScrollRoot: function () { return true; },\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n    checkIsScrollRoot: function (instance) {\n        return Boolean(window.getComputedStyle(instance).position === \"fixed\");\n    },\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { __assign } from 'tslib';\nimport { drag } from '../../motion/features/drag.mjs';\nimport { layoutFeatures } from '../../motion/features/layout/index.mjs';\nimport { domAnimation } from './features-animation.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\n/**\n * @public\n */\nvar domMax = __assign(__assign(__assign(__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\n\nexport { domMax };\n"],"names":["MotionConfig","_a","children","isValidProp","config","useContext","isStatic","context","useMemo","JSON","stringify","transition","transformPagePoint","reducedMotion","value","isPoint","point","hasOwnProperty","isPoint3D","distance1D","a","b","Math","abs","distance","xDelta","x","yDelta","y","zDelta","z","sqrt","pow","PanSession","event","handlers","_this","this","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","offset","timestamp","push","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","end","onEnd","onSessionEnd","panInfo","touches","length","initialInfo","onSessionStart","removeListeners","pipe","window","prototype","updateHandlers","subtractPoint","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","i","timestampedPoint","lastPoint","time","currentVelocity","Infinity","calcLength","axis","max","min","isNear","target","maxDistance","calcAxisDelta","source","origin","originPoint","mix","scale","isNaN","translate","calcBoxDelta","originX","originY","calcRelativeAxis","relative","parent","calcRelativeAxisPosition","layout","calcRelativePosition","calcRelativeAxisConstraints","undefined","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","createDelta","createBox","eachAxis","callback","elementDragControls","WeakMap","VisualElementDragControls","visualElement","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","start","originEvent","_c","snapToCursor","isPresent","panSession","stopAnimation","_b","getProps","drag","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","current","getAxisMotionValue","get","measuredAxis","actual","parseFloat","animationState","setActive","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","getCurrentDirection","updateAxis","syncRender","stop","getTransformPagePoint","cancel","startAnimation","onDragEnd","_point","shouldDrag","axisValue","next","set","dragConstraints","prevConstraints","resolveRefConstraints","layoutBox","top","left","bottom","right","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","measure","root","measuredConstraints","calcViewportConstraints","userConstraints","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","bounceStiffness","bounceDamping","inertia","type","timeConstant","restDelta","restSpeed","startAxisValueAnimation","Promise","all","then","dragKey","toUpperCase","getValue","initial","scalePositionWithinConstraints","boxProgress","sourceLength","targetLength","latest","progress","clamp","transformTemplate","getInstance","style","transform","updateScroll","updateLayout","addListeners","element","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","addEventListener","stopResizeListener","hasLayoutChanged","motionValue","props","_d","_e","_f","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useRef","MotionConfigContext","useEffect","groupDragControls","dragControls","subscribe","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","concat","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","replace","match","shadow","complex","template","xScale","yScale","averageScale","output","i_1","cssVariable","MeasureLayoutWithContext","_super","apply","arguments","componentDidMount","layoutGroup","switchLayoutGroup","layoutId","defaultScaleCorrectors","group","add","register","didUpdate","safeToRemove","setOptions","options","onExitComplete","getSnapshotBeforeUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","componentDidUpdate","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","render","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","SwitchLayoutGroupContext","borders","numBorders","asNumber","isPx","getRadius","values","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","easing","p","copyAxisInto","originAxis","copyBoxInto","box","originBox","removePointDelta","boxScale","removeAxisTransforms","transforms","sourceAxis","key","scaleKey","originKey","removeAxisDelta","xKeys","yKeys","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","scheduleRender","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","instance","resumeFrom","preserveOpacity","snapshot","latestValues","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","forEach","call","resumingFrom","removeLeadSnapshot","identityProjection","buildProjectionTransform","latestTransform","xTranslate","yTranslate","rotate","rotateX","rotateY","elementScaleX","elementScaleY","compareByDepth","depth","FlatTree","isDirty","child","sort","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","ProjectionNode","id","Set","isTreeAnimating","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","Map","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","isVisible","animationProgress","sharedNodes","path","registerPotentialNode","name","handler","has","notifyListeners","args","_i","subscriptionManager","notify","hasListeners","mount","SVGElement","tagName","delete","unblockTimeout_1","resizeUnblockUpdate_1","clearTimeout","setTimeout","finishAnimation","registerSharedNode","animate","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","getDefaultTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","onPlay","onComplete","shouldReduceMotion","delay","unmount","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","size","mountNodeEarly","clear","resetTransformStyle","notifyLayoutUpdate","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measured","removeTransform","removeElementScroll","roundBox","alwaysMeasureLayout","prevLayout","layoutCorrected","notifyLayoutMeasure","layoutScroll","isScrollRoot","scroll","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","measureViewportBox","boxWithoutScroll","scroll_1","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","Boolean","attemptToResolveRelativeTarget","pendingAnimation","getLead","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","some","hasOpacityCrossfade","mixTargetDelta","from","to","mixAxisDelta","mixAxis","follow","opacity","opacityExit","borderLabel","followRadius","leadRadius","mixValues","isAnimating","onUpdate","completeAnimation","applyTransformsToTarget","initialPromotionConfig","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","getStaticValue","setStaticValue","getProjectionStyles","styleProp","styles","visibility","pointerEvents","emptyStyles","valuesToRender","transformOrigin","_h","corrected","num","resetTree","layout_1","measuredLayout","animationType","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","duration","ease","searchNode","document","querySelector","roundAxis","round","DocumentProjectionNode","ref","documentElement","scrollLeft","body","scrollTop","rootProjectionNode","HTMLProjectionNode","documentNode","getComputedStyle","position","domMax","projectionNodeConstructor"],"sourceRoot":""}