{"version":3,"file":"react/js/vendor.framer-motion@current-91a3b8f0.398bf9003322e6308787.js","mappings":"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","sources":["webpack:///./node_modules/framer-motion/dist/es/debug/record.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/circ.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/ease.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/utils/is-bezier-definition.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/back.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/utils/map.mjs","webpack:///./node_modules/framer-motion/dist/es/easing/anticipate.mjs","webpack:///./node_modules/framer-motion/dist/es/events/add-dom-event.mjs","webpack:///./node_modules/framer-motion/dist/es/events/add-pointer-event.mjs","webpack:///./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack:///./node_modules/framer-motion/dist/es/events/utils/is-primary-pointer.mjs","webpack:///./node_modules/framer-motion/dist/es/frameloop/render-step.mjs","webpack:///./node_modules/framer-motion/dist/es/frameloop/batcher.mjs","webpack:///./node_modules/framer-motion/dist/es/frameloop/frame.mjs","webpack:///./node_modules/framer-motion/dist/es/frameloop/microtask.mjs","webpack:///./node_modules/framer-motion/dist/es/frameloop/sync-time.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/index.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/focus.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/hover.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/pan/PanSession.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/pan/index.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/press.mjs"],"sourcesContent":["function record(data) {\n    if (window.MotionDebug) {\n        window.MotionDebug.record(data);\n    }\n}\n\nexport { record };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst circIn = (p) => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circIn);\n\nexport { circIn, circInOut, circOut };\n","import { noop } from '../utils/noop.mjs';\n\n/*\n  Bezier function generator\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) *\n    t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noop;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { cubicBezier } from './cubic-bezier.mjs';\n\nconst easeIn = cubicBezier(0.42, 0, 1, 1);\nconst easeOut = cubicBezier(0, 0, 0.58, 1);\nconst easeInOut = cubicBezier(0.42, 0, 0.58, 1);\n\nexport { easeIn, easeInOut, easeOut };\n","// Accepts an easing function and returns a new one that outputs mirrored values for\n// the second half of the animation. Turns easeIn into easeInOut.\nconst mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n\nexport { mirrorEasing };\n","// Accepts an easing function and returns a new one that outputs reversed values.\n// Turns easeIn into easeOut.\nconst reverseEasing = (easing) => (p) => 1 - easing(1 - p);\n\nexport { reverseEasing };\n","const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === \"number\";\n\nexport { isBezierDefinition };\n","const isEasingArray = (ease) => {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { isEasingArray };\n","import { cubicBezier } from './cubic-bezier.mjs';\nimport { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst backOut = cubicBezier(0.33, 1.53, 0.69, 0.99);\nconst backIn = reverseEasing(backOut);\nconst backInOut = mirrorEasing(backIn);\n\nexport { backIn, backInOut, backOut };\n","import { invariant } from '../../utils/errors.mjs';\nimport { cubicBezier } from '../cubic-bezier.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { easeIn, easeInOut, easeOut } from '../ease.mjs';\nimport { circIn, circInOut, circOut } from '../circ.mjs';\nimport { backIn, backInOut, backOut } from '../back.mjs';\nimport { anticipate } from '../anticipate.mjs';\n\nconst easingLookup = {\n    linear: noop,\n    easeIn,\n    easeInOut,\n    easeOut,\n    circIn,\n    circInOut,\n    circOut,\n    backIn,\n    backInOut,\n    backOut,\n    anticipate,\n};\nconst easingDefinitionToFunction = (definition) => {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);\n        const [x1, y1, x2, y2] = definition;\n        return cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        invariant(easingLookup[definition] !== undefined, `Invalid easing type '${definition}'`);\n        return easingLookup[definition];\n    }\n    return definition;\n};\n\nexport { easingDefinitionToFunction };\n","import { backIn } from './back.mjs';\n\nconst anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n\nexport { anticipate };\n","function addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\n}\n\nexport { addDomEvent };\n","import { addDomEvent } from './add-dom-event.mjs';\nimport { addPointerInfo } from './event-info.mjs';\n\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, eventName, addPointerInfo(handler), options);\n}\n\nexport { addPointerEvent };\n","import { isPrimaryPointer } from './utils/is-primary-pointer.mjs';\n\nfunction extractEventInfo(event, pointType = \"page\") {\n    return {\n        point: {\n            x: event[`${pointType}X`],\n            y: event[`${pointType}Y`],\n        },\n    };\n}\nconst addPointerInfo = (handler) => {\n    return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));\n};\n\nexport { addPointerInfo, extractEventInfo };\n","const isPrimaryPointer = (event) => {\n    if (event.pointerType === \"mouse\") {\n        return typeof event.button !== \"number\" || event.button <= 0;\n    }\n    else {\n        /**\n         * isPrimary is true for all mice buttons, whereas every touch point\n         * is regarded as its own input. So subsequent concurrent touch points\n         * will be false.\n         *\n         * Specifically match against false here as incomplete versions of\n         * PointerEvents in very old browser might have it set as undefined.\n         */\n        return event.isPrimary !== false;\n    }\n};\n\nexport { isPrimaryPointer };\n","class Queue {\n    constructor() {\n        this.order = [];\n        this.scheduled = new Set();\n    }\n    add(process) {\n        if (!this.scheduled.has(process)) {\n            this.scheduled.add(process);\n            this.order.push(process);\n            return true;\n        }\n    }\n    remove(process) {\n        const index = this.order.indexOf(process);\n        if (index !== -1) {\n            this.order.splice(index, 1);\n            this.scheduled.delete(process);\n        }\n    }\n    clear() {\n        this.order.length = 0;\n        this.scheduled.clear();\n    }\n}\nfunction createRenderStep(runNextFrame) {\n    /**\n     * We create and reuse two queues, one to queue jobs for the current frame\n     * and one for the next. We reuse to avoid triggering GC after x frames.\n     */\n    let thisFrame = new Queue();\n    let nextFrame = new Queue();\n    let numToRun = 0;\n    /**\n     * Track whether we're currently processing jobs in this step. This way\n     * we can decide whether to schedule new jobs for this frame or next.\n     */\n    let isProcessing = false;\n    let flushNextFrame = false;\n    /**\n     * A set of processes which were marked keepAlive when scheduled.\n     */\n    const toKeepAlive = new WeakSet();\n    const step = {\n        /**\n         * Schedule a process to run on the next frame.\n         */\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const queue = addToCurrentFrame ? thisFrame : nextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            if (queue.add(callback) && addToCurrentFrame && isProcessing) {\n                // If we're adding it to the currently running queue, update its measured size\n                numToRun = thisFrame.order.length;\n            }\n            return callback;\n        },\n        /**\n         * Cancel the provided callback from running on the next frame.\n         */\n        cancel: (callback) => {\n            nextFrame.remove(callback);\n            toKeepAlive.delete(callback);\n        },\n        /**\n         * Execute all schedule callbacks.\n         */\n        process: (frameData) => {\n            /**\n             * If we're already processing we've probably been triggered by a flushSync\n             * inside an existing process. Instead of executing, mark flushNextFrame\n             * as true and ensure we flush the following frame at the end of this one.\n             */\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            [thisFrame, nextFrame] = [nextFrame, thisFrame];\n            // Clear the next frame queue\n            nextFrame.clear();\n            // Execute this frame\n            numToRun = thisFrame.order.length;\n            if (numToRun) {\n                for (let i = 0; i < numToRun; i++) {\n                    const callback = thisFrame.order[i];\n                    if (toKeepAlive.has(callback)) {\n                        step.schedule(callback);\n                        runNextFrame();\n                    }\n                    callback(frameData);\n                }\n            }\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n","import { MotionGlobalConfig } from '../utils/GlobalConfig.mjs';\nimport { createRenderStep } from './render-step.mjs';\n\nconst stepsOrder = [\n    \"read\", // Read\n    \"resolveKeyframes\", // Write/Read/Write/Read\n    \"update\", // Compute\n    \"preRender\", // Compute\n    \"render\", // Write\n    \"postRender\", // Compute\n];\nconst maxElapsed = 40;\nfunction createRenderBatcher(scheduleNextBatch, allowKeepAlive) {\n    let runNextFrame = false;\n    let useDefaultElapsed = true;\n    const state = {\n        delta: 0,\n        timestamp: 0,\n        isProcessing: false,\n    };\n    const steps = stepsOrder.reduce((acc, key) => {\n        acc[key] = createRenderStep(() => (runNextFrame = true));\n        return acc;\n    }, {});\n    const processStep = (stepId) => {\n        steps[stepId].process(state);\n    };\n    const processBatch = () => {\n        const timestamp = MotionGlobalConfig.useManualTiming\n            ? state.timestamp\n            : performance.now();\n        runNextFrame = false;\n        state.delta = useDefaultElapsed\n            ? 1000 / 60\n            : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);\n        state.timestamp = timestamp;\n        state.isProcessing = true;\n        stepsOrder.forEach(processStep);\n        state.isProcessing = false;\n        if (runNextFrame && allowKeepAlive) {\n            useDefaultElapsed = false;\n            scheduleNextBatch(processBatch);\n        }\n    };\n    const wake = () => {\n        runNextFrame = true;\n        useDefaultElapsed = true;\n        if (!state.isProcessing) {\n            scheduleNextBatch(processBatch);\n        }\n    };\n    const schedule = stepsOrder.reduce((acc, key) => {\n        const step = steps[key];\n        acc[key] = (process, keepAlive = false, immediate = false) => {\n            if (!runNextFrame)\n                wake();\n            return step.schedule(process, keepAlive, immediate);\n        };\n        return acc;\n    }, {});\n    const cancel = (process) => stepsOrder.forEach((key) => steps[key].cancel(process));\n    return { schedule, cancel, state, steps };\n}\n\nexport { createRenderBatcher, stepsOrder };\n","import { noop } from '../utils/noop.mjs';\nimport { createRenderBatcher } from './batcher.mjs';\n\nconst { schedule: frame, cancel: cancelFrame, state: frameData, steps, } = createRenderBatcher(typeof requestAnimationFrame !== \"undefined\" ? requestAnimationFrame : noop, true);\n\nexport { cancelFrame, frame, frameData, steps };\n","import { createRenderBatcher } from './batcher.mjs';\n\nconst { schedule: microtask, cancel: cancelMicrotask } = createRenderBatcher(queueMicrotask, false);\n\nexport { cancelMicrotask, microtask };\n","import { MotionGlobalConfig } from '../utils/GlobalConfig.mjs';\nimport { frameData } from './frame.mjs';\n\nlet now;\nfunction clearTime() {\n    now = undefined;\n}\n/**\n * An eventloop-synchronous alternative to performance.now().\n *\n * Ensures that time measurements remain consistent within a synchronous context.\n * Usually calling performance.now() twice within the same synchronous context\n * will return different values which isn't useful for animations when we're usually\n * trying to sync animations to the same frame.\n */\nconst time = {\n    now: () => {\n        if (now === undefined) {\n            time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming\n                ? frameData.timestamp\n                : performance.now());\n        }\n        return now;\n    },\n    set: (newTime) => {\n        now = newTime;\n        queueMicrotask(clearTime);\n    },\n};\n\nexport { time };\n","import { progress } from '../../../utils/progress.mjs';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { mixNumber } from '../../../utils/mix/number.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, { min, max }, elastic) {\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic\n            ? mixNumber(min, point, elastic.min)\n            : 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\n            ? mixNumber(max, point, elastic.max)\n            : 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, { top, left, bottom, 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    let min = constraintsAxis.min - layoutAxis.min;\n    let 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        [min, max] = [max, min];\n    }\n    return { min, 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    let origin = 0.5;\n    const sourceLength = calcLength(source);\n    const 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    const 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}\nconst defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(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    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : dragElastic[label] || 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","import { invariant } from '../../utils/errors.mjs';\nimport { PanSession } from '../pan/PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, calcViewportConstraints, rebaseAxisConstraints, calcOrigin, defaultElastic } from './utils/constraints.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 { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/add-dom-event.mjs';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\nimport { mixNumber } from '../../utils/mix/number.mjs';\nimport { percent } from '../../value/types/numbers/units.mjs';\nimport { animateMotionValue } from '../../animation/interfaces/motion-value.mjs';\nimport { getContextWindow } from '../../utils/get-context-window.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: PointerEvent\nclass VisualElementDragControls {\n    constructor(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    start(originEvent, { snapToCursor = false } = {}) {\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        const { presenceContext } = this.visualElement;\n        if (presenceContext && presenceContext.isPresent === false)\n            return;\n        const onSessionStart = (event) => {\n            const { dragSnapToOrigin } = this.getProps();\n            // Stop or pause any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            dragSnapToOrigin ? this.pauseAnimation() : this.stopAnimation();\n            if (snapToCursor) {\n                this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        const onStart = (event, info) => {\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            const { drag, dragPropagation, onDragStart } = this.getProps();\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((axis) => {\n                let 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                    const { projection } = this.visualElement;\n                    if (projection && projection.layout) {\n                        const measuredAxis = projection.layout.layoutBox[axis];\n                        if (measuredAxis) {\n                            const length = calcLength(measuredAxis);\n                            current = length * (parseFloat(current) / 100);\n                        }\n                    }\n                }\n                this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            if (onDragStart) {\n                frame.postRender(() => onDragStart(event, info));\n            }\n            const { animationState } = this.visualElement;\n            animationState && animationState.setActive(\"whileDrag\", true);\n        };\n        const onMove = (event, info) => {\n            // latestPointerEvent = event\n            const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !this.openGlobalLock)\n                return;\n            const { offset } = info;\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 && 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.render();\n            /**\n             * This must fire after the render call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag && onDrag(event, info);\n        };\n        const onSessionEnd = (event, info) => this.stop(event, info);\n        const resumeAnimation = () => eachAxis((axis) => {\n            var _a;\n            return this.getAnimationState(axis) === \"paused\" &&\n                ((_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.play());\n        });\n        const { dragSnapToOrigin } = this.getProps();\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart,\n            onStart,\n            onMove,\n            onSessionEnd,\n            resumeAnimation,\n        }, {\n            transformPagePoint: this.visualElement.getTransformPagePoint(),\n            dragSnapToOrigin,\n            contextWindow: getContextWindow(this.visualElement),\n        });\n    }\n    stop(event, info) {\n        const isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        const { velocity } = info;\n        this.startAnimation(velocity);\n        const { onDragEnd } = this.getProps();\n        if (onDragEnd) {\n            frame.postRender(() => onDragEnd(event, info));\n        }\n    }\n    cancel() {\n        this.isDragging = false;\n        const { projection, animationState } = this.visualElement;\n        if (projection) {\n            projection.isAnimationBlocked = false;\n        }\n        this.panSession && this.panSession.end();\n        this.panSession = undefined;\n        const { dragPropagation } = this.getProps();\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        animationState && animationState.setActive(\"whileDrag\", false);\n    }\n    updateAxis(axis, _point, offset) {\n        const { drag } = this.getProps();\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        const axisValue = this.getAxisMotionValue(axis);\n        let 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    resolveConstraints() {\n        var _a;\n        const { dragConstraints, dragElastic } = this.getProps();\n        const layout = this.visualElement.projection &&\n            !this.visualElement.projection.layout\n            ? this.visualElement.projection.measure(false)\n            : (_a = this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout;\n        const 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.layoutBox, 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((axis) => {\n                if (this.constraints !== false &&\n                    this.getAxisMotionValue(axis)) {\n                    this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);\n                }\n            });\n        }\n    }\n    resolveRefConstraints() {\n        const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        const 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        const { projection } = this.visualElement;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, 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            const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    }\n    startAnimation(velocity) {\n        const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();\n        const constraints = this.constraints || {};\n        const momentumAnimations = eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, this.currentDirection)) {\n                return;\n            }\n            let transition = (constraints && constraints[axis]) || {};\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            const bounceStiffness = dragElastic ? 200 : 1000000;\n            const bounceDamping = dragElastic ? 40 : 10000000;\n            const inertia = {\n                type: \"inertia\",\n                velocity: dragMomentum ? velocity[axis] : 0,\n                bounceStiffness,\n                bounceDamping,\n                timeConstant: 750,\n                restDelta: 1,\n                restSpeed: 10,\n                ...dragTransition,\n                ...transition,\n            };\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    startAxisValueAnimation(axis, transition) {\n        const axisValue = this.getAxisMotionValue(axis);\n        return axisValue.start(animateMotionValue(axis, axisValue, 0, transition, this.visualElement));\n    }\n    stopAnimation() {\n        eachAxis((axis) => this.getAxisMotionValue(axis).stop());\n    }\n    pauseAnimation() {\n        eachAxis((axis) => { var _a; return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.pause(); });\n    }\n    getAnimationState(axis) {\n        var _a;\n        return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.state;\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    getAxisMotionValue(axis) {\n        const dragKey = `_drag${axis.toUpperCase()}`;\n        const props = this.visualElement.getProps();\n        const externalMotionValue = props[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (props.initial\n                ? props.initial[axis]\n                : undefined) || 0);\n    }\n    snapToCursor(point) {\n        eachAxis((axis) => {\n            const { drag } = this.getProps();\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, this.currentDirection))\n                return;\n            const { projection } = this.visualElement;\n            const axisValue = this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                const { min, max } = projection.layout.layoutBox[axis];\n                axisValue.set(point[axis] - mixNumber(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    scalePositionWithinConstraints() {\n        if (!this.visualElement.current)\n            return;\n        const { drag, dragConstraints } = this.getProps();\n        const { projection } = this.visualElement;\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        const boxProgress = { x: 0, y: 0 };\n        eachAxis((axis) => {\n            const axisValue = this.getAxisMotionValue(axis);\n            if (axisValue && this.constraints !== false) {\n                const 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        const { transformTemplate } = this.visualElement.getProps();\n        this.visualElement.current.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        projection.root && projection.root.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((axis) => {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            const axisValue = this.getAxisMotionValue(axis);\n            const { min, max } = this.constraints[axis];\n            axisValue.set(mixNumber(min, max, boxProgress[axis]));\n        });\n    }\n    addListeners() {\n        if (!this.visualElement.current)\n            return;\n        elementDragControls.set(this.visualElement, this);\n        const element = this.visualElement.current;\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        const stopPointerListener = addPointerEvent(element, \"pointerdown\", (event) => {\n            const { drag, dragListener = true } = this.getProps();\n            drag && dragListener && this.start(event);\n        });\n        const measureDragConstraints = () => {\n            const { dragConstraints } = this.getProps();\n            if (isRefObject(dragConstraints)) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        };\n        const { projection } = this.visualElement;\n        const stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            projection.root && projection.root.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        const stopResizeListener = addDomEvent(window, \"resize\", () => this.scalePositionWithinConstraints());\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        const stopLayoutUpdateListener = projection.addEventListener(\"didUpdate\", (({ delta, hasLayoutChanged }) => {\n            if (this.isDragging && hasLayoutChanged) {\n                eachAxis((axis) => {\n                    const 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.render();\n            }\n        }));\n        return () => {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n            stopLayoutUpdateListener && stopLayoutUpdateListener();\n        };\n    }\n    getProps() {\n        const props = this.visualElement.getProps();\n        const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;\n        return {\n            ...props,\n            drag,\n            dragDirectionLock,\n            dragPropagation,\n            dragConstraints,\n            dragElastic,\n            dragMomentum,\n        };\n    }\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 = 10) {\n    let 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 { Feature } from '../../motion/features/Feature.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\n\nclass DragGesture extends Feature {\n    constructor(node) {\n        super(node);\n        this.removeGroupControls = noop;\n        this.removeListeners = noop;\n        this.controls = new VisualElementDragControls(node);\n    }\n    mount() {\n        // If we've been provided a DragControls for manual control over the drag gesture,\n        // subscribe this component to it on mount.\n        const { dragControls } = this.node.getProps();\n        if (dragControls) {\n            this.removeGroupControls = dragControls.subscribe(this.controls);\n        }\n        this.removeListeners = this.controls.addListeners() || noop;\n    }\n    unmount() {\n        this.removeGroupControls();\n        this.removeListeners();\n    }\n}\n\nexport { DragGesture };\n","function createLock(name) {\n    let lock = null;\n    return () => {\n        const openLock = () => {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nconst globalHorizontalLock = createLock(\"dragHorizontal\");\nconst globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    let lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        const openHorizontal = globalHorizontalLock();\n        const openVertical = globalVerticalLock();\n        if (openHorizontal && openVertical) {\n            lock = () => {\n                openHorizontal();\n                openVertical();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal)\n                openHorizontal();\n            if (openVertical)\n                openVertical();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    const openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","import { addDomEvent } from '../events/add-dom-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\n\nclass FocusGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.isActive = false;\n    }\n    onFocus() {\n        let isFocusVisible = false;\n        /**\n         * If this element doesn't match focus-visible then don't\n         * apply whileHover. But, if matches throws that focus-visible\n         * is not a valid selector then in that browser outline styles will be applied\n         * to the element by default and we want to match that behaviour with whileFocus.\n         */\n        try {\n            isFocusVisible = this.node.current.matches(\":focus-visible\");\n        }\n        catch (e) {\n            isFocusVisible = true;\n        }\n        if (!isFocusVisible || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", true);\n        this.isActive = true;\n    }\n    onBlur() {\n        if (!this.isActive || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", false);\n        this.isActive = false;\n    }\n    mount() {\n        this.unmount = pipe(addDomEvent(this.node.current, \"focus\", () => this.onFocus()), addDomEvent(this.node.current, \"blur\", () => this.onBlur()));\n    }\n    unmount() { }\n}\n\nexport { FocusGesture };\n","import { addPointerEvent } from '../events/add-pointer-event.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\nfunction addHoverEvent(node, isActive) {\n    const eventName = isActive ? \"pointerenter\" : \"pointerleave\";\n    const callbackName = isActive ? \"onHoverStart\" : \"onHoverEnd\";\n    const handleEvent = (event, info) => {\n        if (event.pointerType === \"touch\" || isDragActive())\n            return;\n        const props = node.getProps();\n        if (node.animationState && props.whileHover) {\n            node.animationState.setActive(\"whileHover\", isActive);\n        }\n        const callback = props[callbackName];\n        if (callback) {\n            frame.postRender(() => callback(event, info));\n        }\n    };\n    return addPointerEvent(node.current, eventName, handleEvent, {\n        passive: !node.getProps()[callbackName],\n    });\n}\nclass HoverGesture extends Feature {\n    mount() {\n        this.unmount = pipe(addHoverEvent(this.node, true), addHoverEvent(this.node, false));\n    }\n    unmount() { }\n}\n\nexport { HoverGesture };\n","import { extractEventInfo } from '../../events/event-info.mjs';\nimport { secondsToMilliseconds, millisecondsToSeconds } from '../../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { pipe } from '../../utils/pipe.mjs';\nimport { distance2D } from '../../utils/distance.mjs';\nimport { isPrimaryPointer } from '../../events/utils/is-primary-pointer.mjs';\nimport { frame, cancelFrame, frameData } from '../../frameloop/frame.mjs';\n\n/**\n * @internal\n */\nclass PanSession {\n    constructor(event, handlers, { transformPagePoint, contextWindow, dragSnapToOrigin = false } = {}) {\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        /**\n         * @internal\n         */\n        this.contextWindow = window;\n        this.updatePoint = () => {\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const info = getPanInfo(this.lastMoveEventInfo, this.history);\n            const 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            const isDistancePastThreshold = distance2D(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            const { point } = info;\n            const { timestamp } = frameData;\n            this.history.push({ ...point, timestamp });\n            const { onStart, onMove } = this.handlers;\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 = (event, info) => {\n            this.lastMoveEvent = event;\n            this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);\n            // Throttle mouse move event to once per frame\n            frame.update(this.updatePoint, true);\n        };\n        this.handlePointerUp = (event, info) => {\n            this.end();\n            const { onEnd, onSessionEnd, resumeAnimation } = this.handlers;\n            if (this.dragSnapToOrigin)\n                resumeAnimation && resumeAnimation();\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const panInfo = getPanInfo(event.type === \"pointercancel\"\n                ? this.lastMoveEventInfo\n                : 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 (!isPrimaryPointer(event))\n            return;\n        this.dragSnapToOrigin = dragSnapToOrigin;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        this.contextWindow = contextWindow || window;\n        const info = extractEventInfo(event);\n        const initialInfo = transformPoint(info, this.transformPagePoint);\n        const { point } = initialInfo;\n        const { timestamp } = frameData;\n        this.history = [{ ...point, timestamp }];\n        const { onSessionStart } = handlers;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(this.contextWindow, \"pointermove\", this.handlePointerMove), addPointerEvent(this.contextWindow, \"pointerup\", this.handlePointerUp), addPointerEvent(this.contextWindow, \"pointercancel\", this.handlePointerUp));\n    }\n    updateHandlers(handlers) {\n        this.handlers = handlers;\n    }\n    end() {\n        this.removeListeners && this.removeListeners();\n        cancelFrame(this.updatePoint);\n    }\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({ point }, history) {\n    return {\n        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    let i = history.length - 1;\n    let timestampedPoint = null;\n    const 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    const time = millisecondsToSeconds(lastPoint.timestamp - timestampedPoint.timestamp);\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    const 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 { PanSession } from './PanSession.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { Feature } from '../../motion/features/Feature.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { getContextWindow } from '../../utils/get-context-window.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst asyncHandler = (handler) => (event, info) => {\n    if (handler) {\n        frame.postRender(() => handler(event, info));\n    }\n};\nclass PanGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removePointerDownListener = noop;\n    }\n    onPointerDown(pointerDownEvent) {\n        this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), {\n            transformPagePoint: this.node.getTransformPagePoint(),\n            contextWindow: getContextWindow(this.node),\n        });\n    }\n    createPanHandlers() {\n        const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();\n        return {\n            onSessionStart: asyncHandler(onPanSessionStart),\n            onStart: asyncHandler(onPanStart),\n            onMove: onPan,\n            onEnd: (event, info) => {\n                delete this.session;\n                if (onPanEnd) {\n                    frame.postRender(() => onPanEnd(event, info));\n                }\n            },\n        };\n    }\n    mount() {\n        this.removePointerDownListener = addPointerEvent(this.node.current, \"pointerdown\", (event) => this.onPointerDown(event));\n    }\n    update() {\n        this.session && this.session.updateHandlers(this.createPanHandlers());\n    }\n    unmount() {\n        this.removePointerDownListener();\n        this.session && this.session.end();\n    }\n}\n\nexport { PanGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nconst isNodeOrChild = (parent, child) => {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","import { extractEventInfo } from '../events/event-info.mjs';\nimport { addDomEvent } from '../events/add-dom-event.mjs';\nimport { addPointerEvent } from '../events/add-pointer-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { noop } from '../utils/noop.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\nfunction fireSyntheticPointerEvent(name, handler) {\n    if (!handler)\n        return;\n    const syntheticPointerEvent = new PointerEvent(\"pointer\" + name);\n    handler(syntheticPointerEvent, extractEventInfo(syntheticPointerEvent));\n}\nclass PressGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removeStartListeners = noop;\n        this.removeEndListeners = noop;\n        this.removeAccessibleListeners = noop;\n        this.startPointerPress = (startEvent, startInfo) => {\n            if (this.isPressing)\n                return;\n            this.removeEndListeners();\n            const props = this.node.getProps();\n            const endPointerPress = (endEvent, endInfo) => {\n                if (!this.checkPressEnd())\n                    return;\n                const { onTap, onTapCancel, globalTapTarget } = this.node.getProps();\n                /**\n                 * We only count this as a tap gesture if the event.target is the same\n                 * as, or a child of, this component's element\n                 */\n                const handler = !globalTapTarget &&\n                    !isNodeOrChild(this.node.current, endEvent.target)\n                    ? onTapCancel\n                    : onTap;\n                if (handler) {\n                    frame.update(() => handler(endEvent, endInfo));\n                }\n            };\n            const removePointerUpListener = addPointerEvent(window, \"pointerup\", endPointerPress, {\n                passive: !(props.onTap || props[\"onPointerUp\"]),\n            });\n            const removePointerCancelListener = addPointerEvent(window, \"pointercancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo), {\n                passive: !(props.onTapCancel ||\n                    props[\"onPointerCancel\"]),\n            });\n            this.removeEndListeners = pipe(removePointerUpListener, removePointerCancelListener);\n            this.startPress(startEvent, startInfo);\n        };\n        this.startAccessiblePress = () => {\n            const handleKeydown = (keydownEvent) => {\n                if (keydownEvent.key !== \"Enter\" || this.isPressing)\n                    return;\n                const handleKeyup = (keyupEvent) => {\n                    if (keyupEvent.key !== \"Enter\" || !this.checkPressEnd())\n                        return;\n                    fireSyntheticPointerEvent(\"up\", (event, info) => {\n                        const { onTap } = this.node.getProps();\n                        if (onTap) {\n                            frame.postRender(() => onTap(event, info));\n                        }\n                    });\n                };\n                this.removeEndListeners();\n                this.removeEndListeners = addDomEvent(this.node.current, \"keyup\", handleKeyup);\n                fireSyntheticPointerEvent(\"down\", (event, info) => {\n                    this.startPress(event, info);\n                });\n            };\n            const removeKeydownListener = addDomEvent(this.node.current, \"keydown\", handleKeydown);\n            const handleBlur = () => {\n                if (!this.isPressing)\n                    return;\n                fireSyntheticPointerEvent(\"cancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo));\n            };\n            const removeBlurListener = addDomEvent(this.node.current, \"blur\", handleBlur);\n            this.removeAccessibleListeners = pipe(removeKeydownListener, removeBlurListener);\n        };\n    }\n    startPress(event, info) {\n        this.isPressing = true;\n        const { onTapStart, whileTap } = this.node.getProps();\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        if (whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", true);\n        }\n        if (onTapStart) {\n            frame.postRender(() => onTapStart(event, info));\n        }\n    }\n    checkPressEnd() {\n        this.removeEndListeners();\n        this.isPressing = false;\n        const props = this.node.getProps();\n        if (props.whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", false);\n        }\n        return !isDragActive();\n    }\n    cancelPress(event, info) {\n        if (!this.checkPressEnd())\n            return;\n        const { onTapCancel } = this.node.getProps();\n        if (onTapCancel) {\n            frame.postRender(() => onTapCancel(event, info));\n        }\n    }\n    mount() {\n        const props = this.node.getProps();\n        const removePointerListener = addPointerEvent(props.globalTapTarget ? window : this.node.current, \"pointerdown\", this.startPointerPress, {\n            passive: !(props.onTapStart ||\n                props[\"onPointerStart\"]),\n        });\n        const removeFocusListener = addDomEvent(this.node.current, \"focus\", this.startAccessiblePress);\n        this.removeStartListeners = pipe(removePointerListener, removeFocusListener);\n    }\n    unmount() {\n        this.removeStartListeners();\n        this.removeEndListeners();\n        this.removeAccessibleListeners();\n    }\n}\n\nexport { PressGesture };\n"],"names":["record","data","window","MotionDebug","circIn","p","Math","sin","acos","circOut","circInOut","calcBezier","t","a1","a2","subdivisionPrecision","subdivisionMaxIterations","cubicBezier","mX1","mY1","mX2","mY2","getTForX","aX","x","lowerBound","upperBound","currentX","currentT","i","abs","binarySubdivide","easeIn","easeOut","easeInOut","mirrorEasing","easing","reverseEasing","isBezierDefinition","Array","isArray","isEasingArray","ease","backOut","backIn","reverse","backInOut","mirror","easingLookup","linear","noop","anticipate","pow","easingDefinitionToFunction","definition","length","x1","y1","x2","y2","undefined","addDomEvent","target","eventName","handler","options","passive","addEventListener","removeEventListener","addPointerEvent","extractEventInfo","event","pointType","point","y","addPointerInfo","isPrimaryPointer","pointerType","button","isPrimary","Queue","constructor","this","order","scheduled","Set","add","process","has","push","remove","index","indexOf","splice","delete","clear","stepsOrder","maxElapsed","createRenderBatcher","scheduleNextBatch","allowKeepAlive","runNextFrame","useDefaultElapsed","state","delta","timestamp","isProcessing","steps","reduce","acc","key","thisFrame","nextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","schedule","callback","keepAlive","immediate","addToCurrentFrame","queue","cancel","frameData","createRenderStep","processStep","stepId","processBatch","useManualTiming","performance","now","max","min","forEach","frame","cancelFrame","requestAnimationFrame","microtask","cancelMicrotask","queueMicrotask","clearTime","time","set","newTime","calcRelativeAxisConstraints","axis","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","elementDragControls","WeakMap","VisualElementDragControls","visualElement","openGlobalLock","isDragging","currentDirection","originPoint","constraints","hasMutatedConstraints","elastic","start","originEvent","snapToCursor","presenceContext","isPresent","dragSnapToOrigin","getProps","panSession","PanSession","onSessionStart","pauseAnimation","stopAnimation","e","onStart","info","drag","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","current","getAxisMotionValue","get","test","layout","measuredAxis","layoutBox","parseFloat","postRender","animationState","setActive","onMove","dragDirectionLock","onDirectionLock","onDrag","offset","lockThreshold","direction","getCurrentDirection","updateAxis","render","onSessionEnd","stop","resumeAnimation","_a","getAnimationState","animation","play","transformPagePoint","getTransformPagePoint","contextWindow","velocity","startAnimation","onDragEnd","end","_point","shouldDrag","axisValue","next","applyConstraints","dragConstraints","measure","prevConstraints","resolveRefConstraints","top","left","bottom","right","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","root","measuredConstraints","calcViewportConstraints","userConstraints","dragMomentum","dragTransition","onDragTransitionEnd","momentumAnimations","transition","bounceStiffness","bounceDamping","inertia","type","timeConstant","restDelta","restSpeed","startAxisValueAnimation","Promise","all","then","pause","dragKey","toUpperCase","props","externalMotionValue","getValue","initial","scalePositionWithinConstraints","boxProgress","latest","source","origin","sourceLength","targetLength","progress","clamp","calcOrigin","transformTemplate","style","transform","updateScroll","updateLayout","addListeners","element","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","stopLayoutUpdateListener","hasLayoutChanged","motionValue","translate","DragGesture","Feature","node","super","removeGroupControls","removeListeners","controls","mount","dragControls","subscribe","unmount","createLock","name","lock","openLock","globalHorizontalLock","globalVerticalLock","getGlobalLock","openHorizontal","openVertical","isDragActive","openGestureLock","FocusGesture","arguments","isActive","onFocus","isFocusVisible","matches","onBlur","addHoverEvent","callbackName","whileHover","HoverGesture","handlers","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","getPanInfo","history","isPanStarted","isDistancePastThreshold","handlePointerMove","transformPoint","update","handlePointerUp","onEnd","panInfo","initialInfo","updateHandlers","subtractPoint","a","b","lastDevicePoint","startDevicePoint","getVelocity","timeDelta","timestampedPoint","lastPoint","currentVelocity","Infinity","asyncHandler","PanGesture","removePointerDownListener","onPointerDown","pointerDownEvent","session","createPanHandlers","onPanSessionStart","onPanStart","onPan","onPanEnd","isNodeOrChild","parent","child","parentElement","fireSyntheticPointerEvent","syntheticPointerEvent","PointerEvent","PressGesture","removeStartListeners","removeEndListeners","removeAccessibleListeners","startPointerPress","startInfo","isPressing","removePointerUpListener","endEvent","endInfo","checkPressEnd","onTap","onTapCancel","globalTapTarget","removePointerCancelListener","cancelEvent","cancelInfo","cancelPress","pipe","startPress","startAccessiblePress","removeKeydownListener","keydownEvent","keyupEvent","removeBlurListener","onTapStart","whileTap","removePointerListener","removeFocusListener"],"sourceRoot":""}