{"version":3,"file":"size-rollup-scroll.js","sources":["../../motion-utils/dist/es/clamp.mjs","../../motion-utils/dist/es/format-error-message.mjs","../../motion-utils/dist/es/errors.mjs","../../motion-utils/dist/es/global-config.mjs","../../motion-utils/dist/es/is-object.mjs","../../motion-utils/dist/es/noop.mjs","../../motion-utils/dist/es/pipe.mjs","../../motion-utils/dist/es/progress.mjs","../../motion-dom/dist/es/frameloop/order.mjs","../../motion-dom/dist/es/frameloop/batcher.mjs","../../motion-dom/dist/es/frameloop/render-step.mjs","../../motion-dom/dist/es/frameloop/frame.mjs","../../motion-dom/dist/es/animation/utils/is-css-variable.mjs","../../motion-dom/dist/es/value/types/numbers/index.mjs","../../motion-dom/dist/es/value/types/utils/sanitize.mjs","../../motion-dom/dist/es/value/types/utils/float-regex.mjs","../../motion-dom/dist/es/value/types/utils/single-color-regex.mjs","../../motion-dom/dist/es/value/types/color/utils.mjs","../../motion-dom/dist/es/value/types/utils/is-nullish.mjs","../../motion-dom/dist/es/value/types/color/rgba.mjs","../../motion-dom/dist/es/value/types/color/hex.mjs","../../motion-dom/dist/es/value/types/numbers/units.mjs","../../motion-dom/dist/es/value/types/color/hsla.mjs","../../motion-dom/dist/es/value/types/color/index.mjs","../../motion-dom/dist/es/value/types/utils/color-regex.mjs","../../motion-dom/dist/es/value/types/complex/index.mjs","../../motion-dom/dist/es/value/types/color/hsla-to-rgba.mjs","../../motion-dom/dist/es/utils/mix/immediate.mjs","../../motion-dom/dist/es/utils/mix/number.mjs","../../motion-dom/dist/es/utils/mix/color.mjs","../../motion-dom/dist/es/utils/mix/visibility.mjs","../../motion-dom/dist/es/utils/mix/complex.mjs","../../motion-dom/dist/es/utils/mix/index.mjs","../../motion-dom/dist/es/utils/interpolate.mjs","../../motion-dom/dist/es/animation/keyframes/offsets/default.mjs","../../motion-dom/dist/es/animation/keyframes/offsets/fill.mjs","../../motion-dom/dist/es/utils/supports/flags.mjs","../../motion-dom/dist/es/utils/supports/memo.mjs","../../motion-utils/dist/es/memo.mjs","../../motion-dom/dist/es/utils/supports/scroll-timeline.mjs","../../motion-dom/dist/es/utils/is-html-element.mjs","../../motion-dom/dist/es/resize/handle-element.mjs","../../motion-dom/dist/es/utils/is-svg-element.mjs","../../motion-dom/dist/es/utils/resolve-elements.mjs","../../motion-dom/dist/es/resize/handle-window.mjs","../../motion-dom/dist/es/scroll/observe.mjs","../lib/render/dom/scroll/utils/can-use-native-timeline.js","../lib/render/dom/scroll/info.js","../../motion-utils/dist/es/velocity-per-second.mjs","../lib/render/dom/scroll/offsets/edge.js","../lib/render/dom/scroll/offsets/offset.js","../lib/render/dom/scroll/offsets/presets.js","../lib/render/dom/scroll/offsets/index.js","../lib/render/dom/scroll/offsets/inset.js","../lib/render/dom/scroll/on-scroll-handler.js","../lib/render/dom/scroll/track.js","../../motion-dom/dist/es/resize/index.mjs","../lib/render/dom/scroll/utils/offset-to-range.js","../lib/render/dom/scroll/utils/get-timeline.js","../lib/render/dom/scroll/index.js","../lib/render/dom/scroll/attach-function.js","../lib/render/dom/scroll/utils/is-element-tracking.js","../lib/render/dom/scroll/attach-animation.js"],"sourcesContent":["const clamp = (min, max, v) => {\n    if (v > max)\n        return max;\n    if (v < min)\n        return min;\n    return v;\n};\n\nexport { clamp };\n//# sourceMappingURL=clamp.mjs.map\n","function formatErrorMessage(message, errorCode) {\n    return errorCode\n        ? `${message}. For more information and steps for solving, visit https://motion.dev/troubleshooting/${errorCode}`\n        : message;\n}\n\nexport { formatErrorMessage };\n//# sourceMappingURL=format-error-message.mjs.map\n","import { formatErrorMessage } from './format-error-message.mjs';\n\nlet warning = () => { };\nlet invariant = () => { };\nif (typeof process !== \"undefined\" &&\n    process.env?.NODE_ENV !== \"production\") {\n    warning = (check, message, errorCode) => {\n        if (!check && typeof console !== \"undefined\") {\n            console.warn(formatErrorMessage(message, errorCode));\n        }\n    };\n    invariant = (check, message, errorCode) => {\n        if (!check) {\n            throw new Error(formatErrorMessage(message, errorCode));\n        }\n    };\n}\n\nexport { invariant, warning };\n//# sourceMappingURL=errors.mjs.map\n","const MotionGlobalConfig = {};\n\nexport { MotionGlobalConfig };\n//# sourceMappingURL=global-config.mjs.map\n","const isObject = (value) => typeof value === \"object\" && value !== null;\n\nexport { isObject };\n//# sourceMappingURL=is-object.mjs.map\n","/*#__NO_SIDE_EFFECTS__*/\nconst noop = (any) => any;\n\nexport { noop };\n//# sourceMappingURL=noop.mjs.map\n","/**\n * Pipe\n * Compose other transformers to run linearily\n * pipe(min(20), max(40))\n * @param  {...functions} transformers\n * @return {function}\n */\nconst pipe = (...transformers) => transformers.reduce((a, b) => (v) => b(a(v)));\n\nexport { pipe };\n//# sourceMappingURL=pipe.mjs.map\n","/*\n  Progress within given range\n\n  Given a lower limit and an upper limit, we return the progress\n  (expressed as a number 0-1) represented by the given value, and\n  limit that progress to within 0-1.\n*/\n/*#__NO_SIDE_EFFECTS__*/\nconst progress = (from, to, value) => {\n    const range = to - from;\n    return range ? (value - from) / range : 1;\n};\n\nexport { progress };\n//# sourceMappingURL=progress.mjs.map\n","const stepsOrder = [\n    \"setup\", // Compute\n    \"read\", // Read\n    \"resolveKeyframes\", // Write/Read/Write/Read\n    \"preUpdate\", // Compute\n    \"update\", // Compute\n    \"preRender\", // Compute\n    \"render\", // Write\n    \"postRender\", // Compute\n];\n\nexport { stepsOrder };\n//# sourceMappingURL=order.mjs.map\n","import { MotionGlobalConfig } from 'motion-utils';\nimport { stepsOrder } from './order.mjs';\nimport { createRenderStep } from './render-step.mjs';\n\nconst maxElapsed = 40;\nfunction createRenderBatcher(scheduleNextBatch, allowKeepAlive) {\n    let runNextFrame = false;\n    let useDefaultElapsed = true;\n    const state = {\n        delta: 0.0,\n        timestamp: 0.0,\n        isProcessing: false,\n    };\n    const flagRunNextFrame = () => (runNextFrame = true);\n    const steps = stepsOrder.reduce((acc, key) => {\n        acc[key] = createRenderStep(flagRunNextFrame, allowKeepAlive ? key : undefined);\n        return acc;\n    }, {});\n    const { setup, read, resolveKeyframes, preUpdate, update, preRender, render, postRender, } = steps;\n    const processBatch = () => {\n        const useManualTiming = MotionGlobalConfig.useManualTiming;\n        const timestamp = useManualTiming\n            ? state.timestamp\n            : performance.now();\n        runNextFrame = false;\n        if (!useManualTiming) {\n            state.delta = useDefaultElapsed\n                ? 1000 / 60\n                : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);\n        }\n        state.timestamp = timestamp;\n        state.isProcessing = true;\n        // Unrolled render loop for better per-frame performance\n        setup.process(state);\n        read.process(state);\n        resolveKeyframes.process(state);\n        preUpdate.process(state);\n        update.process(state);\n        preRender.process(state);\n        render.process(state);\n        postRender.process(state);\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) => {\n        for (let i = 0; i < stepsOrder.length; i++) {\n            steps[stepsOrder[i]].cancel(process);\n        }\n    };\n    return { schedule, cancel, state, steps };\n}\n\nexport { createRenderBatcher };\n//# sourceMappingURL=batcher.mjs.map\n","import { statsBuffer } from '../stats/buffer.mjs';\n\nfunction createRenderStep(runNextFrame, stepName) {\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 Set();\n    let nextFrame = new Set();\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    let latestFrameData = {\n        delta: 0.0,\n        timestamp: 0.0,\n        isProcessing: false,\n    };\n    let numCalls = 0;\n    function triggerCallback(callback) {\n        if (toKeepAlive.has(callback)) {\n            step.schedule(callback);\n            runNextFrame();\n        }\n        numCalls++;\n        callback(latestFrameData);\n    }\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            queue.add(callback);\n            return callback;\n        },\n        /**\n         * Cancel the provided callback from running on the next frame.\n         */\n        cancel: (callback) => {\n            nextFrame.delete(callback);\n            toKeepAlive.delete(callback);\n        },\n        /**\n         * Execute all schedule callbacks.\n         */\n        process: (frameData) => {\n            latestFrameData = 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            // Swap this frame and the next to avoid GC\n            const prevFrame = thisFrame;\n            thisFrame = nextFrame;\n            nextFrame = prevFrame;\n            // Execute this frame\n            thisFrame.forEach(triggerCallback);\n            /**\n             * If we're recording stats then\n             */\n            if (stepName && statsBuffer.value) {\n                statsBuffer.value.frameloop[stepName].push(numCalls);\n            }\n            numCalls = 0;\n            // Clear the frame so no callbacks remain. This is to avoid\n            // memory leaks should this render step not run for a while.\n            thisFrame.clear();\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n//# sourceMappingURL=render-step.mjs.map\n","import { noop } from 'motion-utils';\nimport { createRenderBatcher } from './batcher.mjs';\n\nconst { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps, } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== \"undefined\" ? requestAnimationFrame : noop, true);\n\nexport { cancelFrame, frame, frameData, frameSteps };\n//# sourceMappingURL=frame.mjs.map\n","const checkStringStartsWith = (token) => (key) => typeof key === \"string\" && key.startsWith(token);\nconst isCSSVariableName = \n/*@__PURE__*/ checkStringStartsWith(\"--\");\nconst startsAsVariableToken = \n/*@__PURE__*/ checkStringStartsWith(\"var(--\");\nconst isCSSVariableToken = (value) => {\n    const startsWithToken = startsAsVariableToken(value);\n    if (!startsWithToken)\n        return false;\n    // Ensure any comments are stripped from the value as this can harm performance of the regex.\n    return singleCssVariableRegex.test(value.split(\"/*\")[0].trim());\n};\nconst singleCssVariableRegex = /var\\(--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)$/iu;\n/**\n * Check if a value contains a CSS variable anywhere (e.g. inside calc()).\n * Unlike isCSSVariableToken which checks if the value IS a var() token,\n * this checks if the value CONTAINS var() somewhere in the string.\n */\nfunction containsCSSVariable(value) {\n    if (typeof value !== \"string\")\n        return false;\n    // Strip comments to avoid false positives\n    return value.split(\"/*\")[0].includes(\"var(--\");\n}\n\nexport { containsCSSVariable, isCSSVariableName, isCSSVariableToken };\n//# sourceMappingURL=is-css-variable.mjs.map\n","import { clamp } from 'motion-utils';\n\nconst number = {\n    test: (v) => typeof v === \"number\",\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = {\n    ...number,\n    transform: (v) => clamp(0, 1, v),\n};\nconst scale = {\n    ...number,\n    default: 1,\n};\n\nexport { alpha, number, scale };\n//# sourceMappingURL=index.mjs.map\n","// If this number is a decimal, make it just five decimal places\n// to avoid exponents\nconst sanitize = (v) => Math.round(v * 100000) / 100000;\n\nexport { sanitize };\n//# sourceMappingURL=sanitize.mjs.map\n","const floatRegex = /-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/gu;\n\nexport { floatRegex };\n//# sourceMappingURL=float-regex.mjs.map\n","const singleColorRegex = /^(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))$/iu;\n\nexport { singleColorRegex };\n//# sourceMappingURL=single-color-regex.mjs.map\n","import { floatRegex } from '../utils/float-regex.mjs';\nimport { isNullish } from '../utils/is-nullish.mjs';\nimport { singleColorRegex } from '../utils/single-color-regex.mjs';\n\n/**\n * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,\n * but false if a number or multiple colors\n */\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((typeof v === \"string\" &&\n        singleColorRegex.test(v) &&\n        v.startsWith(type)) ||\n        (testProp &&\n            !isNullish(v) &&\n            Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (typeof v !== \"string\")\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n//# sourceMappingURL=utils.mjs.map\n","function isNullish(v) {\n    return v == null;\n}\n\nexport { isNullish };\n//# sourceMappingURL=is-nullish.mjs.map\n","import { clamp } from 'motion-utils';\nimport { number, alpha } from '../numbers/index.mjs';\nimport { sanitize } from '../utils/sanitize.mjs';\nimport { splitColor, isColorString } from './utils.mjs';\n\nconst clampRgbUnit = (v) => clamp(0, 255, v);\nconst rgbUnit = {\n    ...number,\n    transform: (v) => Math.round(clampRgbUnit(v)),\n};\nconst rgba = {\n    test: /*@__PURE__*/ isColorString(\"rgb\", \"red\"),\n    parse: /*@__PURE__*/ splitColor(\"red\", \"green\", \"blue\"),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => \"rgba(\" +\n        rgbUnit.transform(red) +\n        \", \" +\n        rgbUnit.transform(green) +\n        \", \" +\n        rgbUnit.transform(blue) +\n        \", \" +\n        sanitize(alpha.transform(alpha$1)) +\n        \")\",\n};\n\nexport { rgbUnit, rgba };\n//# sourceMappingURL=rgba.mjs.map\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = \"\";\n    let g = \"\";\n    let b = \"\";\n    let a = \"\";\n    // If we have 6 characters, ie #FF0000\n    if (v.length > 5) {\n        r = v.substring(1, 3);\n        g = v.substring(3, 5);\n        b = v.substring(5, 7);\n        a = v.substring(7, 9);\n        // Or we have 3 characters, ie #F00\n    }\n    else {\n        r = v.substring(1, 2);\n        g = v.substring(2, 3);\n        b = v.substring(3, 4);\n        a = v.substring(4, 5);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: /*@__PURE__*/ isColorString(\"#\"),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n//# sourceMappingURL=hex.mjs.map\n","/*#__NO_SIDE_EFFECTS__*/\nconst createUnitType = (unit) => ({\n    test: (v) => typeof v === \"string\" && v.endsWith(unit) && v.split(\" \").length === 1,\n    parse: parseFloat,\n    transform: (v) => `${v}${unit}`,\n});\nconst degrees = /*@__PURE__*/ createUnitType(\"deg\");\nconst percent = /*@__PURE__*/ createUnitType(\"%\");\nconst px = /*@__PURE__*/ createUnitType(\"px\");\nconst vh = /*@__PURE__*/ createUnitType(\"vh\");\nconst vw = /*@__PURE__*/ createUnitType(\"vw\");\nconst progressPercentage = /*@__PURE__*/ (() => ({\n    ...percent,\n    parse: (v) => percent.parse(v) / 100,\n    transform: (v) => percent.transform(v * 100),\n}))();\n\nexport { degrees, percent, progressPercentage, px, vh, vw };\n//# sourceMappingURL=units.mjs.map\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils/sanitize.mjs';\nimport { splitColor, isColorString } from './utils.mjs';\n\nconst hsla = {\n    test: /*@__PURE__*/ isColorString(\"hsl\", \"hue\"),\n    parse: /*@__PURE__*/ splitColor(\"hue\", \"saturation\", \"lightness\"),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return (\"hsla(\" +\n            Math.round(hue) +\n            \", \" +\n            percent.transform(sanitize(saturation)) +\n            \", \" +\n            percent.transform(sanitize(lightness)) +\n            \", \" +\n            sanitize(alpha.transform(alpha$1)) +\n            \")\");\n    },\n};\n\nexport { hsla };\n//# sourceMappingURL=hsla.mjs.map\n","import { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return typeof v === \"string\"\n            ? v\n            : v.hasOwnProperty(\"red\")\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n    getAnimatableNone: (v) => {\n        const parsed = color.parse(v);\n        parsed.alpha = 0;\n        return color.transform(parsed);\n    },\n};\n\nexport { color };\n//# sourceMappingURL=index.mjs.map\n","const colorRegex = /(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))/giu;\n\nexport { colorRegex };\n//# sourceMappingURL=color-regex.mjs.map\n","import { color } from '../color/index.mjs';\nimport { colorRegex } from '../utils/color-regex.mjs';\nimport { floatRegex } from '../utils/float-regex.mjs';\nimport { sanitize } from '../utils/sanitize.mjs';\n\nfunction test(v) {\n    return (isNaN(v) &&\n        typeof v === \"string\" &&\n        (v.match(floatRegex)?.length || 0) +\n            (v.match(colorRegex)?.length || 0) >\n            0);\n}\nconst NUMBER_TOKEN = \"number\";\nconst COLOR_TOKEN = \"color\";\nconst VAR_TOKEN = \"var\";\nconst VAR_FUNCTION_TOKEN = \"var(\";\nconst SPLIT_TOKEN = \"${}\";\n// this regex consists of the `singleCssVariableRegex|rgbHSLValueRegex|digitRegex`\nconst complexRegex = /var\\s*\\(\\s*--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)|#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\)|-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/giu;\nfunction analyseComplexValue(value) {\n    const originalValue = value.toString();\n    const values = [];\n    const indexes = {\n        color: [],\n        number: [],\n        var: [],\n    };\n    const types = [];\n    let i = 0;\n    const tokenised = originalValue.replace(complexRegex, (parsedValue) => {\n        if (color.test(parsedValue)) {\n            indexes.color.push(i);\n            types.push(COLOR_TOKEN);\n            values.push(color.parse(parsedValue));\n        }\n        else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {\n            indexes.var.push(i);\n            types.push(VAR_TOKEN);\n            values.push(parsedValue);\n        }\n        else {\n            indexes.number.push(i);\n            types.push(NUMBER_TOKEN);\n            values.push(parseFloat(parsedValue));\n        }\n        ++i;\n        return SPLIT_TOKEN;\n    });\n    const split = tokenised.split(SPLIT_TOKEN);\n    return { values, split, indexes, types };\n}\nfunction parseComplexValue(v) {\n    return analyseComplexValue(v).values;\n}\nfunction buildTransformer({ split, types }) {\n    const numSections = split.length;\n    return (v) => {\n        let output = \"\";\n        for (let i = 0; i < numSections; i++) {\n            output += split[i];\n            if (v[i] !== undefined) {\n                const type = types[i];\n                if (type === NUMBER_TOKEN) {\n                    output += sanitize(v[i]);\n                }\n                else if (type === COLOR_TOKEN) {\n                    output += color.transform(v[i]);\n                }\n                else {\n                    output += v[i];\n                }\n            }\n        }\n        return output;\n    };\n}\nfunction createTransformer(source) {\n    return buildTransformer(analyseComplexValue(source));\n}\nconst convertNumbersToZero = (v) => typeof v === \"number\" ? 0 : color.test(v) ? color.getAnimatableNone(v) : v;\n/**\n * Convert a parsed value to its zero equivalent, but preserve numbers\n * that act as divisors in CSS calc() expressions.\n *\n * analyseComplexValue extracts numbers from CSS strings and puts the\n * surrounding text into a `split` template array. For example:\n *   \"calc(var(--gap) / 5)\"  →  values: [var(--gap), 5]\n *                               split:  [\"calc(\", \" / \", \")\"]\n *\n * When building a zero-equivalent for animation, naively zeroing all\n * numbers turns the divisor into 0 → \"calc(var(--gap) / 0)\" → NaN.\n * We detect this by checking whether the text preceding a number\n * (split[i]) ends with \"/\" — the CSS calc division operator.\n */\nconst convertToZero = (value, splitBefore) => {\n    if (typeof value === \"number\") {\n        return splitBefore?.trim().endsWith(\"/\") ? value : 0;\n    }\n    return convertNumbersToZero(value);\n};\nfunction getAnimatableNone(v) {\n    const info = analyseComplexValue(v);\n    const transformer = buildTransformer(info);\n    return transformer(info.values.map((value, i) => convertToZero(value, info.split[i])));\n}\nconst complex = {\n    test,\n    parse: parseComplexValue,\n    createTransformer,\n    getAnimatableNone,\n};\n\nexport { analyseComplexValue, complex };\n//# sourceMappingURL=index.mjs.map\n","// Adapted from https://gist.github.com/mjackson/5311256\nfunction hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n//# sourceMappingURL=hsla-to-rgba.mjs.map\n","function mixImmediate(a, b) {\n    return (p) => (p > 0 ? b : a);\n}\n\nexport { mixImmediate };\n//# sourceMappingURL=immediate.mjs.map\n","/*\n  Value in range from progress\n\n  Given a lower limit and an upper limit, we return the value within\n  that range as expressed by progress (usually a number from 0 to 1)\n\n  So progress = 0.5 would change\n\n  from -------- to\n\n  to\n\n  from ---- to\n\n  E.g. from = 10, to = 20, progress = 0.5 => 15\n\n  @param [number]: Lower limit of range\n  @param [number]: Upper limit of range\n  @param [number]: The progress between lower and upper limits expressed 0-1\n  @return [number]: Value as calculated from progress within range (not limited within range)\n*/\nconst mixNumber = (from, to, progress) => {\n    return from + (to - from) * progress;\n};\n\nexport { mixNumber };\n//# sourceMappingURL=number.mjs.map\n","import { warning } from 'motion-utils';\nimport { hex } from '../../value/types/color/hex.mjs';\nimport { hsla } from '../../value/types/color/hsla.mjs';\nimport { hslaToRgba } from '../../value/types/color/hsla-to-rgba.mjs';\nimport { rgba } from '../../value/types/color/rgba.mjs';\nimport { mixImmediate } from './immediate.mjs';\nimport { mixNumber } from './number.mjs';\n\n// Linear color space blending\n// Explained https://www.youtube.com/watch?v=LKnqECcg6Gw\n// Demonstrated http://codepen.io/osublake/pen/xGVVaN\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const expo = v * (to * to - fromExpo) + fromExpo;\n    return expo < 0 ? 0 : Math.sqrt(expo);\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nfunction asRGBA(color) {\n    const type = getColorType(color);\n    warning(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`, \"color-not-animatable\");\n    if (!Boolean(type))\n        return false;\n    let model = type.parse(color);\n    if (type === hsla) {\n        // TODO Remove this cast - needed since Motion's stricter typing\n        model = hslaToRgba(model);\n    }\n    return model;\n}\nconst mixColor = (from, to) => {\n    const fromRGBA = asRGBA(from);\n    const toRGBA = asRGBA(to);\n    if (!fromRGBA || !toRGBA) {\n        return mixImmediate(from, to);\n    }\n    const blended = { ...fromRGBA };\n    return (v) => {\n        blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);\n        blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);\n        blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);\n        blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v);\n        return rgba.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n//# sourceMappingURL=color.mjs.map\n","const invisibleValues = new Set([\"none\", \"hidden\"]);\n/**\n * Returns a function that, when provided a progress value between 0 and 1,\n * will return the \"none\" or \"hidden\" string only when the progress is that of\n * the origin or target.\n */\nfunction mixVisibility(origin, target) {\n    if (invisibleValues.has(origin)) {\n        return (p) => (p <= 0 ? origin : target);\n    }\n    else {\n        return (p) => (p >= 1 ? target : origin);\n    }\n}\n\nexport { invisibleValues, mixVisibility };\n//# sourceMappingURL=visibility.mjs.map\n","import { pipe, warning } from 'motion-utils';\nimport { isCSSVariableToken } from '../../animation/utils/is-css-variable.mjs';\nimport { color } from '../../value/types/color/index.mjs';\nimport { complex, analyseComplexValue } from '../../value/types/complex/index.mjs';\nimport { mixColor } from './color.mjs';\nimport { mixImmediate } from './immediate.mjs';\nimport { mixNumber as mixNumber$1 } from './number.mjs';\nimport { invisibleValues, mixVisibility } from './visibility.mjs';\n\nfunction mixNumber(a, b) {\n    return (p) => mixNumber$1(a, b, p);\n}\nfunction getMixer(a) {\n    if (typeof a === \"number\") {\n        return mixNumber;\n    }\n    else if (typeof a === \"string\") {\n        return isCSSVariableToken(a)\n            ? mixImmediate\n            : color.test(a)\n                ? mixColor\n                : mixComplex;\n    }\n    else if (Array.isArray(a)) {\n        return mixArray;\n    }\n    else if (typeof a === \"object\") {\n        return color.test(a) ? mixColor : mixObject;\n    }\n    return mixImmediate;\n}\nfunction mixArray(a, b) {\n    const output = [...a];\n    const numValues = output.length;\n    const blendValue = a.map((v, i) => getMixer(v)(v, b[i]));\n    return (p) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](p);\n        }\n        return output;\n    };\n}\nfunction mixObject(a, b) {\n    const output = { ...a, ...b };\n    const blendValue = {};\n    for (const key in output) {\n        if (a[key] !== undefined && b[key] !== undefined) {\n            blendValue[key] = getMixer(a[key])(a[key], b[key]);\n        }\n    }\n    return (v) => {\n        for (const key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n}\nfunction matchOrder(origin, target) {\n    const orderedOrigin = [];\n    const pointers = { color: 0, var: 0, number: 0 };\n    for (let i = 0; i < target.values.length; i++) {\n        const type = target.types[i];\n        const originIndex = origin.indexes[type][pointers[type]];\n        const originValue = origin.values[originIndex] ?? 0;\n        orderedOrigin[i] = originValue;\n        pointers[type]++;\n    }\n    return orderedOrigin;\n}\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyseComplexValue(origin);\n    const targetStats = analyseComplexValue(target);\n    const canInterpolate = originStats.indexes.var.length === targetStats.indexes.var.length &&\n        originStats.indexes.color.length === targetStats.indexes.color.length &&\n        originStats.indexes.number.length >= targetStats.indexes.number.length;\n    if (canInterpolate) {\n        if ((invisibleValues.has(origin) &&\n            !targetStats.values.length) ||\n            (invisibleValues.has(target) &&\n                !originStats.values.length)) {\n            return mixVisibility(origin, target);\n        }\n        return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), template);\n    }\n    else {\n        warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, \"complex-values-different\");\n        return mixImmediate(origin, target);\n    }\n};\n\nexport { getMixer, mixArray, mixComplex, mixObject };\n//# sourceMappingURL=complex.mjs.map\n","import { getMixer } from './complex.mjs';\nimport { mixNumber } from './number.mjs';\n\nfunction mix(from, to, p) {\n    if (typeof from === \"number\" &&\n        typeof to === \"number\" &&\n        typeof p === \"number\") {\n        return mixNumber(from, to, p);\n    }\n    const mixer = getMixer(from);\n    return mixer(from, to);\n}\n\nexport { mix };\n//# sourceMappingURL=index.mjs.map\n","import { invariant, clamp, MotionGlobalConfig, noop, pipe, progress } from 'motion-utils';\nimport { mix } from './mix/index.mjs';\n\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || MotionGlobalConfig.mix || mix;\n    const numMixers = output.length - 1;\n    for (let i = 0; i < numMixers; i++) {\n        let mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            const easingFunction = Array.isArray(ease) ? ease[i] || noop : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\n/**\n * Create a function that maps from a numerical input array to a generic output array.\n *\n * Accepts:\n *   - Numbers\n *   - Colors (hex, hsl, hsla, rgb, rgba)\n *   - Complex (combinations of one or more numbers or strings)\n *\n * ```jsx\n * const mixColor = interpolate([0, 1], ['#fff', '#000'])\n *\n * mixColor(0.5) // 'rgba(128, 128, 128, 1)'\n * ```\n *\n * TODO Revisit this approach once we've moved to data models for values,\n * probably not needed to pregenerate mixer functions.\n *\n * @public\n */\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    invariant(inputLength === output.length, \"Both input and output ranges must be the same length\", \"range-length\");\n    /**\n     * If we're only provided a single input, we can just make a function\n     * that returns the output.\n     */\n    if (inputLength === 1)\n        return () => output[0];\n    if (inputLength === 2 && output[0] === output[1])\n        return () => output[1];\n    const isZeroDeltaRange = input[0] === input[1];\n    // If input runs highest -> lowest, reverse both arrays\n    if (input[0] > input[inputLength - 1]) {\n        input = [...input].reverse();\n        output = [...output].reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const numMixers = mixers.length;\n    const interpolator = (v) => {\n        if (isZeroDeltaRange && v < input[0])\n            return output[0];\n        let i = 0;\n        if (numMixers > 1) {\n            for (; i < input.length - 2; i++) {\n                if (v < input[i + 1])\n                    break;\n            }\n        }\n        const progressInRange = progress(input[i], input[i + 1], v);\n        return mixers[i](progressInRange);\n    };\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\n//# sourceMappingURL=interpolate.mjs.map\n","import { fillOffset } from './fill.mjs';\n\nfunction defaultOffset(arr) {\n    const offset = [0];\n    fillOffset(offset, arr.length - 1);\n    return offset;\n}\n\nexport { defaultOffset };\n//# sourceMappingURL=default.mjs.map\n","import { progress } from 'motion-utils';\nimport { mixNumber } from '../../../utils/mix/number.mjs';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mixNumber(min, 1, offsetProgress));\n    }\n}\n\nexport { fillOffset };\n//# sourceMappingURL=fill.mjs.map\n","/**\n * Add the ability for test suites to manually set support flags\n * to better test more environments.\n */\nconst supportsFlags = {};\n\nexport { supportsFlags };\n//# sourceMappingURL=flags.mjs.map\n","import { memo } from 'motion-utils';\nimport { supportsFlags } from './flags.mjs';\n\nfunction memoSupports(callback, supportsFlag) {\n    const memoized = memo(callback);\n    return () => supportsFlags[supportsFlag] ?? memoized();\n}\n\nexport { memoSupports };\n//# sourceMappingURL=memo.mjs.map\n","/*#__NO_SIDE_EFFECTS__*/\nfunction memo(callback) {\n    let result;\n    return () => {\n        if (result === undefined)\n            result = callback();\n        return result;\n    };\n}\n\nexport { memo };\n//# sourceMappingURL=memo.mjs.map\n","import { memoSupports } from './memo.mjs';\n\nconst supportsScrollTimeline = /* @__PURE__ */ memoSupports(() => window.ScrollTimeline !== undefined, \"scrollTimeline\");\nconst supportsViewTimeline = /* @__PURE__ */ memoSupports(() => window.ViewTimeline !== undefined, \"viewTimeline\");\n\nexport { supportsScrollTimeline, supportsViewTimeline };\n//# sourceMappingURL=scroll-timeline.mjs.map\n","import { isObject } from 'motion-utils';\n\n/**\n * Checks if an element is an HTML element in a way\n * that works across iframes\n */\nfunction isHTMLElement(element) {\n    return (isObject(element) &&\n        \"offsetHeight\" in element &&\n        !(\"ownerSVGElement\" in element));\n}\n\nexport { isHTMLElement };\n//# sourceMappingURL=is-html-element.mjs.map\n","import { isSVGElement } from '../utils/is-svg-element.mjs';\nimport { resolveElements } from '../utils/resolve-elements.mjs';\n\nconst resizeHandlers = new WeakMap();\nlet observer;\nconst getSize = (borderBoxAxis, svgAxis, htmlAxis) => (target, borderBoxSize) => {\n    if (borderBoxSize && borderBoxSize[0]) {\n        return borderBoxSize[0][(borderBoxAxis + \"Size\")];\n    }\n    else if (isSVGElement(target) && \"getBBox\" in target) {\n        return target.getBBox()[svgAxis];\n    }\n    else {\n        return target[htmlAxis];\n    }\n};\nconst getWidth = /*@__PURE__*/ getSize(\"inline\", \"width\", \"offsetWidth\");\nconst getHeight = /*@__PURE__*/ getSize(\"block\", \"height\", \"offsetHeight\");\nfunction notifyTarget({ target, borderBoxSize }) {\n    resizeHandlers.get(target)?.forEach((handler) => {\n        handler(target, {\n            get width() {\n                return getWidth(target, borderBoxSize);\n            },\n            get height() {\n                return getHeight(target, borderBoxSize);\n            },\n        });\n    });\n}\nfunction notifyAll(entries) {\n    entries.forEach(notifyTarget);\n}\nfunction createResizeObserver() {\n    if (typeof ResizeObserver === \"undefined\")\n        return;\n    observer = new ResizeObserver(notifyAll);\n}\nfunction resizeElement(target, handler) {\n    if (!observer)\n        createResizeObserver();\n    const elements = resolveElements(target);\n    elements.forEach((element) => {\n        let elementHandlers = resizeHandlers.get(element);\n        if (!elementHandlers) {\n            elementHandlers = new Set();\n            resizeHandlers.set(element, elementHandlers);\n        }\n        elementHandlers.add(handler);\n        observer?.observe(element);\n    });\n    return () => {\n        elements.forEach((element) => {\n            const elementHandlers = resizeHandlers.get(element);\n            elementHandlers?.delete(handler);\n            if (!elementHandlers?.size) {\n                observer?.unobserve(element);\n            }\n        });\n    };\n}\n\nexport { resizeElement };\n//# sourceMappingURL=handle-element.mjs.map\n","import { isObject } from 'motion-utils';\n\n/**\n * Checks if an element is an SVG element in a way\n * that works across iframes\n */\nfunction isSVGElement(element) {\n    return isObject(element) && \"ownerSVGElement\" in element;\n}\n\nexport { isSVGElement };\n//# sourceMappingURL=is-svg-element.mjs.map\n","function resolveElements(elementOrSelector, scope, selectorCache) {\n    if (elementOrSelector == null) {\n        return [];\n    }\n    if (elementOrSelector instanceof EventTarget) {\n        return [elementOrSelector];\n    }\n    else if (typeof elementOrSelector === \"string\") {\n        let root = document;\n        if (scope) {\n            root = scope.current;\n        }\n        const elements = selectorCache?.[elementOrSelector] ??\n            root.querySelectorAll(elementOrSelector);\n        return elements ? Array.from(elements) : [];\n    }\n    return Array.from(elementOrSelector).filter((element) => element != null);\n}\n\nexport { resolveElements };\n//# sourceMappingURL=resolve-elements.mjs.map\n","const windowCallbacks = new Set();\nlet windowResizeHandler;\nfunction createWindowResizeHandler() {\n    windowResizeHandler = () => {\n        const info = {\n            get width() {\n                return window.innerWidth;\n            },\n            get height() {\n                return window.innerHeight;\n            },\n        };\n        windowCallbacks.forEach((callback) => callback(info));\n    };\n    window.addEventListener(\"resize\", windowResizeHandler);\n}\nfunction resizeWindow(callback) {\n    windowCallbacks.add(callback);\n    if (!windowResizeHandler)\n        createWindowResizeHandler();\n    return () => {\n        windowCallbacks.delete(callback);\n        if (!windowCallbacks.size &&\n            typeof windowResizeHandler === \"function\") {\n            window.removeEventListener(\"resize\", windowResizeHandler);\n            windowResizeHandler = undefined;\n        }\n    };\n}\n\nexport { resizeWindow };\n//# sourceMappingURL=handle-window.mjs.map\n","import { frame, cancelFrame } from '../frameloop/frame.mjs';\n\nfunction observeTimeline(update, timeline) {\n    let prevProgress;\n    const onFrame = () => {\n        const { currentTime } = timeline;\n        const percentage = currentTime === null ? 0 : currentTime.value;\n        const progress = percentage / 100;\n        if (prevProgress !== progress) {\n            update(progress);\n        }\n        prevProgress = progress;\n    };\n    frame.preUpdate(onFrame, true);\n    return () => cancelFrame(onFrame);\n}\n\nexport { observeTimeline };\n//# sourceMappingURL=observe.mjs.map\n","import { supportsScrollTimeline, supportsViewTimeline } from \"motion-dom\";\nexport function canUseNativeTimeline(target) {\n    if (typeof window === \"undefined\")\n        return false;\n    return target ? supportsViewTimeline() : supportsScrollTimeline();\n}\n//# sourceMappingURL=can-use-native-timeline.js.map","import { progress, velocityPerSecond } from \"motion-utils\";\n/**\n * A time in milliseconds, beyond which we consider the scroll velocity to be 0.\n */\nconst maxElapsed = 50;\nconst createAxisInfo = () => ({\n    current: 0,\n    offset: [],\n    progress: 0,\n    scrollLength: 0,\n    targetOffset: 0,\n    targetLength: 0,\n    containerLength: 0,\n    velocity: 0,\n});\nexport const createScrollInfo = () => ({\n    time: 0,\n    x: createAxisInfo(),\n    y: createAxisInfo(),\n});\nconst keys = {\n    x: {\n        length: \"Width\",\n        position: \"Left\",\n    },\n    y: {\n        length: \"Height\",\n        position: \"Top\",\n    },\n};\nfunction updateAxisInfo(element, axisName, info, time) {\n    const axis = info[axisName];\n    const { length, position } = keys[axisName];\n    const prev = axis.current;\n    const prevTime = info.time;\n    axis.current = Math.abs(element[`scroll${position}`]);\n    axis.scrollLength = element[`scroll${length}`] - element[`client${length}`];\n    axis.offset.length = 0;\n    axis.offset[0] = 0;\n    axis.offset[1] = axis.scrollLength;\n    axis.progress = progress(0, axis.scrollLength, axis.current);\n    const elapsed = time - prevTime;\n    axis.velocity =\n        elapsed > maxElapsed\n            ? 0\n            : velocityPerSecond(axis.current - prev, elapsed);\n}\nexport function updateScrollInfo(element, info, time) {\n    updateAxisInfo(element, \"x\", info, time);\n    updateAxisInfo(element, \"y\", info, time);\n    info.time = time;\n}\n//# sourceMappingURL=info.js.map","/*\n  Convert velocity into velocity per second\n*/\n/*#__NO_SIDE_EFFECTS__*/\nconst velocityPerSecond = (velocity, frameDuration) => frameDuration ? velocity * (1000 / frameDuration) : 0;\n\nexport { velocityPerSecond };\n//# sourceMappingURL=velocity-per-second.mjs.map\n","export const namedEdges = {\n    start: 0,\n    center: 0.5,\n    end: 1,\n};\nexport function resolveEdge(edge, length, inset = 0) {\n    let delta = 0;\n    /**\n     * If we have this edge defined as a preset, replace the definition\n     * with the numerical value.\n     */\n    if (edge in namedEdges) {\n        edge = namedEdges[edge];\n    }\n    /**\n     * Handle unit values\n     */\n    if (typeof edge === \"string\") {\n        const asNumber = parseFloat(edge);\n        if (edge.endsWith(\"px\")) {\n            delta = asNumber;\n        }\n        else if (edge.endsWith(\"%\")) {\n            edge = asNumber / 100;\n        }\n        else if (edge.endsWith(\"vw\")) {\n            delta = (asNumber / 100) * document.documentElement.clientWidth;\n        }\n        else if (edge.endsWith(\"vh\")) {\n            delta = (asNumber / 100) * document.documentElement.clientHeight;\n        }\n        else {\n            edge = asNumber;\n        }\n    }\n    /**\n     * If the edge is defined as a number, handle as a progress value.\n     */\n    if (typeof edge === \"number\") {\n        delta = length * edge;\n    }\n    return inset + delta;\n}\n//# sourceMappingURL=edge.js.map","import { namedEdges, resolveEdge } from \"./edge\";\nconst defaultOffset = [0, 0];\nexport function resolveOffset(offset, containerLength, targetLength, targetInset) {\n    let offsetDefinition = Array.isArray(offset) ? offset : defaultOffset;\n    let targetPoint = 0;\n    let containerPoint = 0;\n    if (typeof offset === \"number\") {\n        /**\n         * If we're provided offset: [0, 0.5, 1] then each number x should become\n         * [x, x], so we default to the behaviour of mapping 0 => 0 of both target\n         * and container etc.\n         */\n        offsetDefinition = [offset, offset];\n    }\n    else if (typeof offset === \"string\") {\n        offset = offset.trim();\n        if (offset.includes(\" \")) {\n            offsetDefinition = offset.split(\" \");\n        }\n        else {\n            /**\n             * If we're provided a definition like \"100px\" then we want to apply\n             * that only to the top of the target point, leaving the container at 0.\n             * Whereas a named offset like \"end\" should be applied to both.\n             */\n            offsetDefinition = [offset, namedEdges[offset] ? offset : `0`];\n        }\n    }\n    targetPoint = resolveEdge(offsetDefinition[0], targetLength, targetInset);\n    containerPoint = resolveEdge(offsetDefinition[1], containerLength);\n    return targetPoint - containerPoint;\n}\n//# sourceMappingURL=offset.js.map","export const ScrollOffset = {\n    Enter: [\n        [0, 1],\n        [1, 1],\n    ],\n    Exit: [\n        [0, 0],\n        [1, 0],\n    ],\n    Any: [\n        [1, 0],\n        [0, 1],\n    ],\n    All: [\n        [0, 0],\n        [1, 1],\n    ],\n};\n//# sourceMappingURL=presets.js.map","import { defaultOffset, interpolate } from \"motion-dom\";\nimport { clamp } from \"motion-utils\";\nimport { calcInset } from \"./inset\";\nimport { resolveOffset } from \"./offset\";\nimport { ScrollOffset } from \"./presets\";\nconst point = { x: 0, y: 0 };\nfunction getTargetSize(target) {\n    return \"getBBox\" in target && target.tagName !== \"svg\"\n        ? target.getBBox()\n        : { width: target.clientWidth, height: target.clientHeight };\n}\nexport function resolveOffsets(container, info, options) {\n    const { offset: offsetDefinition = ScrollOffset.All } = options;\n    const { target = container, axis = \"y\" } = options;\n    const lengthLabel = axis === \"y\" ? \"height\" : \"width\";\n    const inset = target !== container ? calcInset(target, container) : point;\n    /**\n     * Measure the target and container. If they're the same thing then we\n     * use the container's scrollWidth/Height as the target, from there\n     * all other calculations can remain the same.\n     */\n    const targetSize = target === container\n        ? { width: container.scrollWidth, height: container.scrollHeight }\n        : getTargetSize(target);\n    const containerSize = {\n        width: container.clientWidth,\n        height: container.clientHeight,\n    };\n    /**\n     * Reset the length of the resolved offset array rather than creating a new one.\n     * TODO: More reusable data structures for targetSize/containerSize would also be good.\n     */\n    info[axis].offset.length = 0;\n    /**\n     * Populate the offset array by resolving the user's offset definition into\n     * a list of pixel scroll offets.\n     */\n    let hasChanged = !info[axis].interpolate;\n    const numOffsets = offsetDefinition.length;\n    for (let i = 0; i < numOffsets; i++) {\n        const offset = resolveOffset(offsetDefinition[i], containerSize[lengthLabel], targetSize[lengthLabel], inset[axis]);\n        if (!hasChanged && offset !== info[axis].interpolatorOffsets[i]) {\n            hasChanged = true;\n        }\n        info[axis].offset[i] = offset;\n    }\n    /**\n     * If the pixel scroll offsets have changed, create a new interpolator function\n     * to map scroll value into a progress.\n     */\n    if (hasChanged) {\n        info[axis].interpolate = interpolate(info[axis].offset, defaultOffset(offsetDefinition), { clamp: false });\n        info[axis].interpolatorOffsets = [...info[axis].offset];\n    }\n    info[axis].progress = clamp(0, 1, info[axis].interpolate(info[axis].current));\n}\n//# sourceMappingURL=index.js.map","import { isHTMLElement } from \"motion-dom\";\nexport function calcInset(element, container) {\n    const inset = { x: 0, y: 0 };\n    let current = element;\n    while (current && current !== container) {\n        if (isHTMLElement(current)) {\n            inset.x += current.offsetLeft;\n            inset.y += current.offsetTop;\n            current = current.offsetParent;\n        }\n        else if (current.tagName === \"svg\") {\n            /**\n             * This isn't an ideal approach to measuring the offset of <svg /> tags.\n             * It would be preferable, given they behave like HTMLElements in most ways\n             * to use offsetLeft/Top. But these don't exist on <svg />. Likewise we\n             * can't use .getBBox() like most SVG elements as these provide the offset\n             * relative to the SVG itself, which for <svg /> is usually 0x0.\n             */\n            const svgBoundingBox = current.getBoundingClientRect();\n            current = current.parentElement;\n            const parentBoundingBox = current.getBoundingClientRect();\n            inset.x += svgBoundingBox.left - parentBoundingBox.left;\n            inset.y += svgBoundingBox.top - parentBoundingBox.top;\n        }\n        else if (current instanceof SVGGraphicsElement) {\n            const { x, y } = current.getBBox();\n            inset.x += x;\n            inset.y += y;\n            let svg = null;\n            let parent = current.parentNode;\n            while (!svg) {\n                if (parent.tagName === \"svg\") {\n                    svg = parent;\n                }\n                parent = current.parentNode;\n            }\n            current = svg;\n        }\n        else {\n            break;\n        }\n    }\n    return inset;\n}\n//# sourceMappingURL=inset.js.map","import { warnOnce } from \"motion-utils\";\nimport { updateScrollInfo } from \"./info\";\nimport { resolveOffsets } from \"./offsets/index\";\nfunction measure(container, target = container, info) {\n    /**\n     * Find inset of target within scrollable container\n     */\n    info.x.targetOffset = 0;\n    info.y.targetOffset = 0;\n    if (target !== container) {\n        let node = target;\n        while (node && node !== container) {\n            info.x.targetOffset += node.offsetLeft;\n            info.y.targetOffset += node.offsetTop;\n            node = node.offsetParent;\n        }\n    }\n    info.x.targetLength =\n        target === container ? target.scrollWidth : target.clientWidth;\n    info.y.targetLength =\n        target === container ? target.scrollHeight : target.clientHeight;\n    info.x.containerLength = container.clientWidth;\n    info.y.containerLength = container.clientHeight;\n    /**\n     * In development mode ensure scroll containers aren't position: static as this makes\n     * it difficult to measure their relative positions. The document scrolling element\n     * is exempt: offsetParent measurements naturally resolve relative to the document.\n     */\n    if (process.env.NODE_ENV !== \"production\") {\n        if (container &&\n            target &&\n            target !== container &&\n            container !== document.documentElement &&\n            container !== document.scrollingElement &&\n            container !== document.body) {\n            warnOnce(getComputedStyle(container).position !== \"static\", \"Please ensure that the container has a non-static position, like 'relative', 'fixed', or 'absolute' to ensure scroll offset is calculated correctly.\");\n        }\n    }\n}\nexport function createOnScrollHandler(element, onScroll, info, options = {}) {\n    return {\n        measure: (time) => {\n            measure(element, options.target, info);\n            updateScrollInfo(element, info, time);\n            if (options.offset || options.target) {\n                resolveOffsets(element, info, options);\n            }\n        },\n        notify: () => onScroll(info),\n    };\n}\n//# sourceMappingURL=on-scroll-handler.js.map","import { cancelFrame, frame, frameData, resize } from \"motion-dom\";\nimport { noop } from \"motion-utils\";\nimport { createScrollInfo } from \"./info\";\nimport { createOnScrollHandler } from \"./on-scroll-handler\";\nconst scrollListeners = new WeakMap();\nconst resizeListeners = new WeakMap();\nconst onScrollHandlers = new WeakMap();\nconst scrollSize = new WeakMap();\nconst dimensionCheckProcesses = new WeakMap();\nconst getEventTarget = (element) => element === document.scrollingElement ? window : element;\nexport function scrollInfo(onScroll, { container = document.scrollingElement, trackContentSize = false, ...options } = {}) {\n    if (!container)\n        return noop;\n    let containerHandlers = onScrollHandlers.get(container);\n    /**\n     * Get the onScroll handlers for this container.\n     * If one isn't found, create a new one.\n     */\n    if (!containerHandlers) {\n        containerHandlers = new Set();\n        onScrollHandlers.set(container, containerHandlers);\n    }\n    /**\n     * Create a new onScroll handler for the provided callback.\n     */\n    const info = createScrollInfo();\n    const containerHandler = createOnScrollHandler(container, onScroll, info, options);\n    containerHandlers.add(containerHandler);\n    /**\n     * Check if there's a scroll event listener for this container.\n     * If not, create one.\n     */\n    if (!scrollListeners.has(container)) {\n        const measureAll = () => {\n            for (const handler of containerHandlers) {\n                handler.measure(frameData.timestamp);\n            }\n            frame.preUpdate(notifyAll);\n        };\n        const notifyAll = () => {\n            for (const handler of containerHandlers) {\n                handler.notify();\n            }\n        };\n        const listener = () => frame.read(measureAll);\n        scrollListeners.set(container, listener);\n        const target = getEventTarget(container);\n        window.addEventListener(\"resize\", listener);\n        if (container !== document.documentElement) {\n            resizeListeners.set(container, resize(container, listener));\n        }\n        target.addEventListener(\"scroll\", listener);\n        listener();\n    }\n    /**\n     * Enable content size tracking if requested and not already enabled.\n     */\n    if (trackContentSize && !dimensionCheckProcesses.has(container)) {\n        const listener = scrollListeners.get(container);\n        // Store initial scroll dimensions (object is reused to avoid allocation)\n        const size = {\n            width: container.scrollWidth,\n            height: container.scrollHeight,\n        };\n        scrollSize.set(container, size);\n        // Add frame-based scroll dimension checking to detect content changes\n        const checkScrollDimensions = () => {\n            const newWidth = container.scrollWidth;\n            const newHeight = container.scrollHeight;\n            if (size.width !== newWidth || size.height !== newHeight) {\n                listener();\n                size.width = newWidth;\n                size.height = newHeight;\n            }\n        };\n        // Schedule with keepAlive=true to run every frame\n        const dimensionCheckProcess = frame.read(checkScrollDimensions, true);\n        dimensionCheckProcesses.set(container, dimensionCheckProcess);\n    }\n    const listener = scrollListeners.get(container);\n    frame.read(listener, false, true);\n    return () => {\n        cancelFrame(listener);\n        /**\n         * Check if we even have any handlers for this container.\n         */\n        const currentHandlers = onScrollHandlers.get(container);\n        if (!currentHandlers)\n            return;\n        currentHandlers.delete(containerHandler);\n        if (currentHandlers.size)\n            return;\n        /**\n         * If no more handlers, remove the scroll listener too.\n         */\n        const scrollListener = scrollListeners.get(container);\n        scrollListeners.delete(container);\n        if (scrollListener) {\n            getEventTarget(container).removeEventListener(\"scroll\", scrollListener);\n            resizeListeners.get(container)?.();\n            window.removeEventListener(\"resize\", scrollListener);\n        }\n        // Clean up scroll dimension checking\n        const dimensionCheckProcess = dimensionCheckProcesses.get(container);\n        if (dimensionCheckProcess) {\n            cancelFrame(dimensionCheckProcess);\n            dimensionCheckProcesses.delete(container);\n        }\n        scrollSize.delete(container);\n    };\n}\n//# sourceMappingURL=track.js.map","import { resizeElement } from './handle-element.mjs';\nimport { resizeWindow } from './handle-window.mjs';\n\nfunction resize(a, b) {\n    return typeof a === \"function\" ? resizeWindow(a) : resizeElement(a, b);\n}\n\nexport { resize };\n//# sourceMappingURL=index.mjs.map\n","import { ScrollOffset as ScrollOffsetPresets } from \"../offsets/presets\";\n/**\n * Maps from ProgressIntersection pairs used by Motion's preset offsets to\n * ViewTimeline named ranges. Returns undefined for unrecognised patterns,\n * which signals the caller to fall back to JS-based scroll tracking.\n */\nconst presets = [\n    [ScrollOffsetPresets.Enter, \"entry\"],\n    [ScrollOffsetPresets.Exit, \"exit\"],\n    [ScrollOffsetPresets.Any, \"cover\"],\n    [ScrollOffsetPresets.All, \"contain\"],\n];\nconst stringToProgress = {\n    start: 0,\n    end: 1,\n};\nfunction parseStringOffset(s) {\n    const parts = s.trim().split(/\\s+/);\n    if (parts.length !== 2)\n        return undefined;\n    const a = stringToProgress[parts[0]];\n    const b = stringToProgress[parts[1]];\n    if (a === undefined || b === undefined)\n        return undefined;\n    return [a, b];\n}\nfunction normaliseOffset(offset) {\n    if (offset.length !== 2)\n        return undefined;\n    const result = [];\n    for (const item of offset) {\n        if (Array.isArray(item)) {\n            result.push(item);\n        }\n        else if (typeof item === \"string\") {\n            const parsed = parseStringOffset(item);\n            if (!parsed)\n                return undefined;\n            result.push(parsed);\n        }\n        else {\n            return undefined;\n        }\n    }\n    return result;\n}\nfunction matchesPreset(offset, preset) {\n    const normalised = normaliseOffset(offset);\n    if (!normalised)\n        return false;\n    for (let i = 0; i < 2; i++) {\n        const o = normalised[i];\n        const p = preset[i];\n        if (o[0] !== p[0] || o[1] !== p[1])\n            return false;\n    }\n    return true;\n}\nexport function offsetToViewTimelineRange(offset) {\n    if (!offset) {\n        return { rangeStart: \"contain 0%\", rangeEnd: \"contain 100%\" };\n    }\n    for (const [preset, name] of presets) {\n        if (matchesPreset(offset, preset)) {\n            return { rangeStart: `${name} 0%`, rangeEnd: `${name} 100%` };\n        }\n    }\n    return undefined;\n}\n//# sourceMappingURL=offset-to-range.js.map","import { scrollInfo } from \"../track\";\nimport { canUseNativeTimeline } from \"./can-use-native-timeline\";\nimport { offsetToViewTimelineRange } from \"./offset-to-range\";\nconst timelineCache = new Map();\nfunction scrollTimelineFallback(options) {\n    const currentTime = { value: 0 };\n    const cancel = scrollInfo((info) => {\n        currentTime.value = info[options.axis].progress * 100;\n    }, options);\n    return { currentTime, cancel };\n}\nexport function getTimeline({ source, container, ...options }) {\n    const { axis } = options;\n    if (source)\n        container = source;\n    let containerCache = timelineCache.get(container);\n    if (!containerCache) {\n        containerCache = new Map();\n        timelineCache.set(container, containerCache);\n    }\n    const targetKey = options.target ?? \"self\";\n    let targetCache = containerCache.get(targetKey);\n    if (!targetCache) {\n        targetCache = {};\n        containerCache.set(targetKey, targetCache);\n    }\n    const axisKey = axis + (options.offset ?? []).join(\",\");\n    if (!targetCache[axisKey]) {\n        if (options.target && canUseNativeTimeline(options.target)) {\n            const range = offsetToViewTimelineRange(options.offset);\n            if (range) {\n                targetCache[axisKey] = new ViewTimeline({\n                    subject: options.target,\n                    axis,\n                });\n            }\n            else {\n                targetCache[axisKey] = scrollTimelineFallback({\n                    container,\n                    ...options,\n                });\n            }\n        }\n        else if (canUseNativeTimeline()) {\n            targetCache[axisKey] = new ScrollTimeline({\n                source: container,\n                axis,\n            });\n        }\n        else {\n            targetCache[axisKey] = scrollTimelineFallback({\n                container,\n                ...options,\n            });\n        }\n    }\n    return targetCache[axisKey];\n}\n//# sourceMappingURL=get-timeline.js.map","import { noop } from \"motion-utils\";\nimport { attachToAnimation } from \"./attach-animation\";\nimport { attachToFunction } from \"./attach-function\";\nexport function scroll(onScroll, { axis = \"y\", container = document.scrollingElement, ...options } = {}) {\n    if (!container)\n        return noop;\n    const optionsWithDefaults = { axis, container, ...options };\n    return typeof onScroll === \"function\"\n        ? attachToFunction(onScroll, optionsWithDefaults)\n        : attachToAnimation(onScroll, optionsWithDefaults);\n}\n//# sourceMappingURL=index.js.map","import { observeTimeline } from \"motion-dom\";\nimport { scrollInfo } from \"./track\";\nimport { getTimeline } from \"./utils/get-timeline\";\nimport { isElementTracking } from \"./utils/is-element-tracking\";\n/**\n * If the onScroll function has two arguments, it's expecting\n * more specific information about the scroll from scrollInfo.\n */\nfunction isOnScrollWithInfo(onScroll) {\n    return onScroll.length === 2;\n}\nexport function attachToFunction(onScroll, options) {\n    if (isOnScrollWithInfo(onScroll) || isElementTracking(options)) {\n        return scrollInfo((info) => {\n            onScroll(info[options.axis].progress, info);\n        }, options);\n    }\n    else {\n        return observeTimeline(onScroll, getTimeline(options));\n    }\n}\n//# sourceMappingURL=attach-function.js.map","/**\n * Currently, we only support element tracking with `scrollInfo`, though in\n * the future we can also offer ViewTimeline support.\n */\nexport function isElementTracking(options) {\n    return options && (options.target || options.offset);\n}\n//# sourceMappingURL=is-element-tracking.js.map","import { observeTimeline } from \"motion-dom\";\nimport { canUseNativeTimeline } from \"./utils/can-use-native-timeline\";\nimport { getTimeline } from \"./utils/get-timeline\";\nimport { offsetToViewTimelineRange } from \"./utils/offset-to-range\";\nexport function attachToAnimation(animation, options) {\n    const timeline = getTimeline(options);\n    const range = options.target\n        ? offsetToViewTimelineRange(options.offset)\n        : undefined;\n    /**\n     * Use native timeline when:\n     * - No target: ScrollTimeline (existing behaviour)\n     * - Target with mappable offset: ViewTimeline with named range\n     * - Target with unmappable offset: fall back to JS observe\n     */\n    const useNative = options.target\n        ? canUseNativeTimeline(options.target) && !!range\n        : canUseNativeTimeline();\n    return animation.attachTimeline({\n        timeline: useNative ? timeline : undefined,\n        ...(range &&\n            useNative && {\n            rangeStart: range.rangeStart,\n            rangeEnd: range.rangeEnd,\n        }),\n        observe: (valueAnimation) => {\n            valueAnimation.pause();\n            return observeTimeline((progress) => {\n                valueAnimation.time =\n                    valueAnimation.iterationDuration * progress;\n            }, timeline);\n        },\n    });\n}\n//# sourceMappingURL=attach-animation.js.map"],"names":["clamp","min","max","v","formatErrorMessage","message","errorCode","warning","invariant","process","env","NODE_ENV","check","console","warn","Error","MotionGlobalConfig","isObject","value","noop","any","pipe","transformers","reduce","a","b","progress","from","to","range","stepsOrder","createRenderBatcher","scheduleNextBatch","allowKeepAlive","runNextFrame","useDefaultElapsed","state","delta","timestamp","isProcessing","flagRunNextFrame","steps","acc","key","thisFrame","Set","nextFrame","flushNextFrame","toKeepAlive","WeakSet","latestFrameData","triggerCallback","callback","has","step","schedule","keepAlive","immediate","queue","add","cancel","delete","frameData","prevFrame","forEach","clear","createRenderStep","setup","read","resolveKeyframes","preUpdate","update","preRender","render","postRender","processBatch","useManualTiming","performance","now","Math","i","length","frame","cancelFrame","requestAnimationFrame","startsAsVariableToken","token","startsWith","checkStringStartsWith","singleCssVariableRegex","number","test","parse","parseFloat","transform","alpha","sanitize","round","floatRegex","singleColorRegex","isColorString","type","testProp","Boolean","isNullish","Object","prototype","hasOwnProperty","call","splitColor","aName","bName","cName","c","match","undefined","rgbUnit","clampRgbUnit","rgba","red","green","blue","alpha$1","hex","r","g","substring","parseInt","percent","unit","endsWith","split","createUnitType","hsla","hue","saturation","lightness","color","getAnimatableNone","parsed","colorRegex","NUMBER_TOKEN","COLOR_TOKEN","complexRegex","analyseComplexValue","originalValue","toString","values","indexes","var","types","replace","parsedValue","push","buildTransformer","numSections","output","convertToZero","splitBefore","trim","complex","isNaN","createTransformer","source","info","transformer","map","hueToRgb","p","q","t","mixImmediate","mixNumber","mixLinearColor","fromExpo","expo","sqrt","colorTypes","asRGBA","find","model","hslaToRgba","mixColor","fromRGBA","toRGBA","blended","invisibleValues","mixNumber$1","getMixer","mixComplex","Array","isArray","mixArray","mixObject","numValues","blendValue","origin","target","template","originStats","targetStats","mixVisibility","orderedOrigin","pointers","originIndex","originValue","matchOrder","mix","mixer","interpolate","input","isClamp","ease","inputLength","isZeroDeltaRange","reverse","mixers","customMixer","mixerFactory","numMixers","easingFunction","createMixers","interpolator","progressInRange","defaultOffset","arr","offset","remaining","offsetProgress","fillOffset","supportsFlags","memoSupports","supportsFlag","memoized","result","memo","supportsScrollTimeline","window","ScrollTimeline","supportsViewTimeline","ViewTimeline","isHTMLElement","element","resizeHandlers","WeakMap","observer","getSize","borderBoxAxis","svgAxis","htmlAxis","borderBoxSize","getBBox","getWidth","getHeight","notifyTarget","get","handler","width","height","notifyAll","entries","resizeElement","ResizeObserver","elements","elementOrSelector","EventTarget","document","querySelectorAll","filter","resolveElements","elementHandlers","set","observe","size","unobserve","windowCallbacks","windowResizeHandler","resizeWindow","innerWidth","innerHeight","addEventListener","removeEventListener","observeTimeline","timeline","prevProgress","onFrame","currentTime","canUseNativeTimeline","keys","x","position","y","updateAxisInfo","axisName","time","axis","prev","current","prevTime","abs","scrollLength","elapsed","velocity","frameDuration","namedEdges","start","center","end","resolveEdge","edge","inset","asNumber","documentElement","clientWidth","clientHeight","resolveOffset","containerLength","targetLength","targetInset","offsetDefinition","targetPoint","containerPoint","includes","ScrollOffset","Enter","Exit","Any","All","point","resolveOffsets","container","options","lengthLabel","offsetLeft","offsetTop","offsetParent","tagName","svgBoundingBox","getBoundingClientRect","parentElement","parentBoundingBox","left","top","SVGGraphicsElement","svg","parent","parentNode","calcInset","targetSize","scrollWidth","scrollHeight","getTargetSize","containerSize","hasChanged","numOffsets","interpolatorOffsets","createOnScrollHandler","onScroll","measure","targetOffset","node","updateScrollInfo","notify","scrollListeners","resizeListeners","onScrollHandlers","scrollSize","dimensionCheckProcesses","getEventTarget","scrollingElement","scrollInfo","trackContentSize","containerHandlers","containerHandler","measureAll","listener","checkScrollDimensions","newWidth","newHeight","dimensionCheckProcess","currentHandlers","scrollListener","presets","ScrollOffsetPresets","stringToProgress","parseStringOffset","s","parts","matchesPreset","preset","normalised","item","normaliseOffset","o","offsetToViewTimelineRange","rangeStart","rangeEnd","name","timelineCache","Map","scrollTimelineFallback","getTimeline","containerCache","targetKey","targetCache","axisKey","join","subject","scroll","optionsWithDefaults","isOnScrollWithInfo","isElementTracking","attachToFunction","animation","useNative","attachTimeline","valueAnimation","pause","iterationDuration","attachToAnimation"],"mappings":"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"}