{"version":3,"file":"7715-1ac78a3bd9419e69ffcf.js","mappings":"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","sources":["webpack://eploy/./node_modules/framer-motion/dist/es/animation/animate.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/is-point.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/is-point-3d.mjs","webpack://eploy/./node_modules/popmotion/dist/es/utils/distance.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/PanSession.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/motion/features/drag.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","webpack://eploy/./node_modules/framer-motion/dist/es/render/dom/features-max.mjs"],"sourcesContent":["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","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 { 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":["animate","from","to","transition","value","stop","isAnimating","isPoint","point","hasOwnProperty","isPoint3D","distance1D","a","b","Math","abs","distance","xDelta","x","yDelta","y","zDelta","z","sqrt","pow","PanSession","event","handlers","_a","_this","this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","offset","timestamp","push","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","update","end","onEnd","onSessionEnd","panInfo","touches","length","initialInfo","e","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","test","measuredAxis","actual","parseFloat","animationState","setActive","Drag","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","getCurrentDirection","updateAxis","syncRender","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","useContext","MotionConfigContext","useEffect","groupDragControls","dragControls","subscribe","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","concat","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","replace","match","shadow","complex","parse","template","createTransformer","xScale","yScale","averageScale","output","i_1","cssVariable","MeasureLayoutWithContext","_super","apply","arguments","componentDidMount","layoutGroup","switchLayoutGroup","layoutId","defaultScaleCorrectors","group","add","register","didUpdate","safeToRemove","setOptions","options","onExitComplete","hasEverUpdated","getSnapshotBeforeUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","postRender","getStack","members","componentDidUpdate","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","render","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","L","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","children","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","hasAnimatedSinceResize","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","getDefaultTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","onPlay","onComplete","shouldReduceMotion","delay","unmount","preRender","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","mixAxisDelta","mixAxis","follow","opacity","opacityExit","borderLabel","followRadius","leadRadius","mixValues","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":""}