{"version":3,"file":"size-rollup-style-effect.js","sources":["../lib/render/dom/is-css-var.js","../lib/render/utils/keys-transform.js","../../motion-utils/dist/es/clamp.mjs","../../motion-utils/dist/es/global-config.mjs","../../motion-utils/dist/es/subscription-manager.mjs","../../motion-utils/dist/es/array.mjs","../lib/frameloop/order.js","../lib/frameloop/batcher.js","../lib/frameloop/render-step.js","../lib/frameloop/frame.js","../../motion-utils/dist/es/noop.mjs","../lib/frameloop/sync-time.js","../lib/value/index.js","../../motion-utils/dist/es/velocity-per-second.mjs","../lib/effects/utils/create-dom-effect.js","../lib/utils/resolve-elements.js","../lib/value/types/numbers/index.js","../lib/value/types/int.js","../lib/value/types/numbers/units.js","../lib/value/types/maps/number.js","../lib/value/types/maps/transform.js","../lib/effects/MotionValueState.js","../lib/value/types/utils/get-as-type.js","../lib/effects/utils/create-effect.js","../lib/effects/style/transform.js","../lib/effects/style/index.js","../lib/utils/is-html-element.js","../../motion-utils/dist/es/is-object.mjs"],"sourcesContent":["export const isCSSVar = (name) => name.startsWith(\"--\");\n//# sourceMappingURL=is-css-var.js.map","/**\n * Generate a list of every possible transform key.\n */\nexport const transformPropOrder = [\n    \"transformPerspective\",\n    \"x\",\n    \"y\",\n    \"z\",\n    \"translateX\",\n    \"translateY\",\n    \"translateZ\",\n    \"scale\",\n    \"scaleX\",\n    \"scaleY\",\n    \"rotate\",\n    \"rotateX\",\n    \"rotateY\",\n    \"rotateZ\",\n    \"skew\",\n    \"skewX\",\n    \"skewY\",\n];\n/**\n * A quick lookup for transform props.\n *\n * `pathRotation` is a transform for routing purposes (skipped from raw\n * style application, wired to the transform composite, flags transform\n * dirty) but is intentionally NOT in `transformPropOrder` — it is\n * composed onto `rotate` at the build sites, not serialized in its own\n * slot, and must stay out of the order-array consumers (parse-transform,\n * unit-conversion, keys-position).\n */\nexport const transformProps = /*@__PURE__*/ (() => new Set([...transformPropOrder, \"pathRotation\"]))();\n//# sourceMappingURL=keys-transform.js.map","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","const MotionGlobalConfig = {};\n\nexport { MotionGlobalConfig };\n//# sourceMappingURL=global-config.mjs.map\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nclass SubscriptionManager {\n    constructor() {\n        this.subscriptions = [];\n    }\n    add(handler) {\n        addUniqueItem(this.subscriptions, handler);\n        return () => removeItem(this.subscriptions, handler);\n    }\n    notify(a, b, c) {\n        const numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (let i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                const handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    }\n    getSize() {\n        return this.subscriptions.length;\n    }\n    clear() {\n        this.subscriptions.length = 0;\n    }\n}\n\nexport { SubscriptionManager };\n//# sourceMappingURL=subscription-manager.mjs.map\n","function addUniqueItem(arr, item) {\n    if (arr.indexOf(item) === -1)\n        arr.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    if (index > -1)\n        arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem([...arr], fromIndex, toIndex) {\n    const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        const [item] = arr.splice(fromIndex, 1);\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n//# sourceMappingURL=array.mjs.map\n","export 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//# sourceMappingURL=order.js.map","import { MotionGlobalConfig } from \"motion-utils\";\nimport { stepsOrder } from \"./order\";\nimport { createRenderStep } from \"./render-step\";\nconst maxElapsed = 40;\nexport function 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//# sourceMappingURL=batcher.js.map","import { statsBuffer } from \"../stats/buffer\";\nexport function 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//# sourceMappingURL=render-step.js.map","import { noop } from \"motion-utils\";\nimport { createRenderBatcher } from \"./batcher\";\nexport const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps, } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== \"undefined\" ? requestAnimationFrame : noop, true);\n//# sourceMappingURL=frame.js.map","/*#__NO_SIDE_EFFECTS__*/\nconst noop = (any) => any;\n\nexport { noop };\n//# sourceMappingURL=noop.mjs.map\n","import { MotionGlobalConfig } from \"motion-utils\";\nimport { frameData } from \"./frame\";\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 */\nexport const 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//# sourceMappingURL=sync-time.js.map","import { SubscriptionManager, velocityPerSecond, warnOnce, } from \"motion-utils\";\nimport { frame } from \"../frameloop\";\nimport { time } from \"../frameloop/sync-time\";\n/**\n * Maximum time between the value of two frames, beyond which we\n * assume the velocity has since been 0.\n */\nconst MAX_VELOCITY_DELTA = 30;\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nexport const collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nexport class MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     */\n    constructor(init, options = {}) {\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = null;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v) => {\n            const currentTime = time.now();\n            /**\n             * If we're updating the value during another frame or eventloop\n             * than the previous frame, then the we set the previous frame value\n             * to current.\n             */\n            if (this.updatedAt !== currentTime) {\n                this.setPrevFrameValue();\n            }\n            this.prev = this.current;\n            this.setCurrent(v);\n            // Update update subscribers\n            if (this.current !== this.prev) {\n                this.events.change?.notify(this.current);\n                if (this.dependents) {\n                    for (const dependent of this.dependents) {\n                        dependent.dirty();\n                    }\n                }\n            }\n        };\n        this.hasAnimated = false;\n        this.setCurrent(init);\n        this.owner = options.owner;\n    }\n    setCurrent(current) {\n        this.current = current;\n        this.updatedAt = time.now();\n        if (this.canTrackVelocity === null && current !== undefined) {\n            this.canTrackVelocity = isFloat(this.current);\n        }\n    }\n    setPrevFrameValue(prevFrameValue = this.current) {\n        this.prevFrameValue = prevFrameValue;\n        this.prevUpdatedAt = this.updatedAt;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v) {\n        if (!this.passiveEffect) {\n            this.updateAndNotify(v);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = undefined;\n        this.prevFrameValue = prev;\n        this.prevUpdatedAt = this.updatedAt - delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v, endAnimation = true) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.prevUpdatedAt = this.prevFrameValue = undefined;\n        endAnimation && this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    dirty() {\n        this.events.change?.notify(this.current);\n    }\n    addDependent(dependent) {\n        if (!this.dependents) {\n            this.dependents = new Set();\n        }\n        this.dependents.add(dependent);\n    }\n    removeDependent(dependent) {\n        if (this.dependents) {\n            this.dependents.delete(dependent);\n        }\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        const currentTime = time.now();\n        if (!this.canTrackVelocity ||\n            this.prevFrameValue === undefined ||\n            currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {\n            return 0;\n        }\n        const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);\n        // Casts because of parseFloat's poor typing\n        return velocityPerSecond(parseFloat(this.current) -\n            parseFloat(this.prevFrameValue), delta);\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        delete this.animation;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.dependents?.clear();\n        this.events.destroy?.notify();\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nexport function motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n//# sourceMappingURL=index.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","import { resolveElements, } from \"../../utils/resolve-elements\";\nexport function createSelectorEffect(subjectEffect) {\n    return (subject, values) => {\n        const elements = resolveElements(subject);\n        const subscriptions = [];\n        for (const element of elements) {\n            const remove = subjectEffect(element, values);\n            subscriptions.push(remove);\n        }\n        return () => {\n            for (const remove of subscriptions)\n                remove();\n        };\n    };\n}\n//# sourceMappingURL=create-dom-effect.js.map","export 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//# sourceMappingURL=resolve-elements.js.map","import { clamp } from \"motion-utils\";\nexport const number = {\n    test: (v) => typeof v === \"number\",\n    parse: parseFloat,\n    transform: (v) => v,\n};\nexport const alpha = {\n    ...number,\n    transform: (v) => clamp(0, 1, v),\n};\nexport const scale = {\n    ...number,\n    default: 1,\n};\n//# sourceMappingURL=index.js.map","import { number } from \"./numbers\";\nexport const int = {\n    ...number,\n    transform: Math.round,\n};\n//# sourceMappingURL=int.js.map","/*#__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});\nexport const degrees = /*@__PURE__*/ createUnitType(\"deg\");\nexport const percent = /*@__PURE__*/ createUnitType(\"%\");\nexport const px = /*@__PURE__*/ createUnitType(\"px\");\nexport const vh = /*@__PURE__*/ createUnitType(\"vh\");\nexport const vw = /*@__PURE__*/ createUnitType(\"vw\");\nexport const progressPercentage = /*@__PURE__*/ (() => ({\n    ...percent,\n    parse: (v) => percent.parse(v) / 100,\n    transform: (v) => percent.transform(v * 100),\n}))();\n//# sourceMappingURL=units.js.map","import { int } from \"../int\";\nimport { alpha } from \"../numbers\";\nimport { px } from \"../numbers/units\";\nimport { transformValueTypes } from \"./transform\";\nexport const numberValueTypes = {\n    // Border props\n    borderWidth: px,\n    borderTopWidth: px,\n    borderRightWidth: px,\n    borderBottomWidth: px,\n    borderLeftWidth: px,\n    borderRadius: px,\n    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    // Positioning props\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: px,\n    top: px,\n    right: px,\n    bottom: px,\n    left: px,\n    inset: px,\n    insetBlock: px,\n    insetBlockStart: px,\n    insetBlockEnd: px,\n    insetInline: px,\n    insetInlineStart: px,\n    insetInlineEnd: px,\n    // Spacing props\n    padding: px,\n    paddingTop: px,\n    paddingRight: px,\n    paddingBottom: px,\n    paddingLeft: px,\n    paddingBlock: px,\n    paddingBlockStart: px,\n    paddingBlockEnd: px,\n    paddingInline: px,\n    paddingInlineStart: px,\n    paddingInlineEnd: px,\n    margin: px,\n    marginTop: px,\n    marginRight: px,\n    marginBottom: px,\n    marginLeft: px,\n    marginBlock: px,\n    marginBlockStart: px,\n    marginBlockEnd: px,\n    marginInline: px,\n    marginInlineStart: px,\n    marginInlineEnd: px,\n    // Typography\n    fontSize: px,\n    // Misc\n    backgroundPositionX: px,\n    backgroundPositionY: px,\n    ...transformValueTypes,\n    zIndex: int,\n    // SVG\n    fillOpacity: alpha,\n    strokeOpacity: alpha,\n    numOctaves: int,\n};\n//# sourceMappingURL=number.js.map","import { alpha, scale } from \"../numbers\";\nimport { degrees, progressPercentage, px } from \"../numbers/units\";\nexport const transformValueTypes = {\n    rotate: degrees,\n    /**\n     * Internal channel for `transition.path` orientToPath. Composed onto\n     * `rotate` at the transform-build sites so the user's `rotate` is\n     * never read or overwritten. Not part of `transformPropOrder`.\n     */\n    pathRotation: degrees,\n    rotateX: degrees,\n    rotateY: degrees,\n    rotateZ: degrees,\n    scale,\n    scaleX: scale,\n    scaleY: scale,\n    scaleZ: scale,\n    skew: degrees,\n    skewX: degrees,\n    skewY: degrees,\n    distance: px,\n    translateX: px,\n    translateY: px,\n    translateZ: px,\n    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    transformPerspective: px,\n    opacity: alpha,\n    originX: progressPercentage,\n    originY: progressPercentage,\n    originZ: px,\n};\n//# sourceMappingURL=transform.js.map","import { cancelFrame, frame } from \"../frameloop/frame\";\nimport { numberValueTypes } from \"../value/types/maps/number\";\nimport { getValueAsType } from \"../value/types/utils/get-as-type\";\nexport class MotionValueState {\n    constructor() {\n        this.latest = {};\n        this.values = new Map();\n    }\n    set(name, value, render, computed, useDefaultValueType = true) {\n        const existingValue = this.values.get(name);\n        if (existingValue) {\n            existingValue.onRemove();\n        }\n        const onChange = () => {\n            const v = value.get();\n            if (useDefaultValueType) {\n                this.latest[name] = getValueAsType(v, numberValueTypes[name]);\n            }\n            else {\n                this.latest[name] = v;\n            }\n            render && frame.render(render);\n        };\n        onChange();\n        const cancelOnChange = value.on(\"change\", onChange);\n        computed && value.addDependent(computed);\n        const remove = () => {\n            cancelOnChange();\n            render && cancelFrame(render);\n            this.values.delete(name);\n            computed && value.removeDependent(computed);\n        };\n        this.values.set(name, { value, onRemove: remove });\n        return remove;\n    }\n    get(name) {\n        return this.values.get(name)?.value;\n    }\n}\n//# sourceMappingURL=MotionValueState.js.map","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nexport const getValueAsType = (value, type) => {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n//# sourceMappingURL=get-as-type.js.map","import { MotionValueState } from \"../MotionValueState\";\nexport function createEffect(addValue) {\n    const stateCache = new WeakMap();\n    return (subject, values) => {\n        const state = stateCache.get(subject) ?? new MotionValueState();\n        stateCache.set(subject, state);\n        const subscriptions = [];\n        for (const key in values) {\n            const value = values[key];\n            const remove = addValue(subject, state, key, value);\n            subscriptions.push(remove);\n        }\n        return () => {\n            for (const cancel of subscriptions)\n                cancel();\n        };\n    };\n}\n//# sourceMappingURL=create-effect.js.map","import { transformPropOrder } from \"../../render/utils/keys-transform\";\nconst translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\nexport function buildTransform(state) {\n    let transform = \"\";\n    let transformIsDefault = true;\n    /**\n     * Loop over all possible transforms in order, adding the ones that\n     * are present to the transform string.\n     */\n    for (let i = 0; i < transformPropOrder.length; i++) {\n        const key = transformPropOrder[i];\n        const value = state.latest[key];\n        if (value === undefined)\n            continue;\n        let valueIsDefault = true;\n        if (typeof value === \"number\") {\n            valueIsDefault = value === (key.startsWith(\"scale\") ? 1 : 0);\n        }\n        else {\n            const parsed = parseFloat(value);\n            valueIsDefault = key.startsWith(\"scale\") ? parsed === 1 : parsed === 0;\n        }\n        if (!valueIsDefault) {\n            transformIsDefault = false;\n            const transformName = translateAlias[key] || key;\n            transform += `${transformName}(${value}) `;\n        }\n    }\n    // See build-transform.ts: additive `rotate()` so user `rotate` isn't\n    // clobbered. Not a `transformPropOrder` slot.\n    const pathRotation = state.latest.pathRotation;\n    if (pathRotation) {\n        transformIsDefault = false;\n        transform += `rotate(${typeof pathRotation === \"number\"\n            ? `${pathRotation}deg`\n            : pathRotation}) `;\n    }\n    return transformIsDefault ? \"none\" : transform.trim();\n}\n//# sourceMappingURL=transform.js.map","import { isCSSVar } from \"../../render/dom/is-css-var\";\nimport { transformProps } from \"../../render/utils/keys-transform\";\nimport { isHTMLElement } from \"../../utils/is-html-element\";\nimport { MotionValue } from \"../../value\";\nimport { createSelectorEffect } from \"../utils/create-dom-effect\";\nimport { createEffect } from \"../utils/create-effect\";\nimport { buildTransform } from \"./transform\";\nconst originProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nexport const addStyleValue = (element, state, key, value) => {\n    let render = undefined;\n    let computed = undefined;\n    if (transformProps.has(key)) {\n        if (!state.get(\"transform\")) {\n            // If this is an HTML element, we need to set the transform-box to fill-box\n            // to normalise the transform relative to the element's bounding box\n            if (!isHTMLElement(element) && !state.get(\"transformBox\")) {\n                addStyleValue(element, state, \"transformBox\", new MotionValue(\"fill-box\"));\n            }\n            state.set(\"transform\", new MotionValue(\"none\"), () => {\n                element.style.transform = buildTransform(state);\n            });\n        }\n        computed = state.get(\"transform\");\n    }\n    else if (originProps.has(key)) {\n        if (!state.get(\"transformOrigin\")) {\n            state.set(\"transformOrigin\", new MotionValue(\"\"), () => {\n                const originX = state.latest.originX ?? \"50%\";\n                const originY = state.latest.originY ?? \"50%\";\n                const originZ = state.latest.originZ ?? 0;\n                element.style.transformOrigin = `${originX} ${originY} ${originZ}`;\n            });\n        }\n        computed = state.get(\"transformOrigin\");\n    }\n    else if (isCSSVar(key)) {\n        render = () => {\n            element.style.setProperty(key, state.latest[key]);\n        };\n    }\n    else {\n        render = () => {\n            element.style[key] = state.latest[key];\n        };\n    }\n    return state.set(key, value, render, computed);\n};\nexport const styleEffect = /*@__PURE__*/ createSelectorEffect(\n/*@__PURE__*/ createEffect(addStyleValue));\n//# sourceMappingURL=index.js.map","import { isObject } from \"motion-utils\";\n/**\n * Checks if an element is an HTML element in a way\n * that works across iframes\n */\nexport function isHTMLElement(element) {\n    return (isObject(element) &&\n        \"offsetHeight\" in element &&\n        !(\"ownerSVGElement\" in element));\n}\n//# sourceMappingURL=is-html-element.js.map","const isObject = (value) => typeof value === \"object\" && value !== null;\n\nexport { isObject };\n//# sourceMappingURL=is-object.mjs.map\n"],"names":["transformPropOrder","transformProps","Set","MotionGlobalConfig","SubscriptionManager","constructor","this","subscriptions","add","handler","arr","item","indexOf","push","index","splice","removeItem","notify","a","b","c","numSubscriptions","length","i","getSize","clear","stepsOrder","createRenderBatcher","scheduleNextBatch","allowKeepAlive","runNextFrame","useDefaultElapsed","state","delta","timestamp","isProcessing","flagRunNextFrame","steps","reduce","acc","key","thisFrame","nextFrame","flushNextFrame","toKeepAlive","WeakSet","latestFrameData","triggerCallback","callback","has","step","schedule","keepAlive","immediate","queue","cancel","delete","process","frameData","prevFrame","forEach","createRenderStep","setup","read","resolveKeyframes","preUpdate","update","preRender","render","postRender","processBatch","useManualTiming","performance","now","Math","max","min","frame","cancelFrame","requestAnimationFrame","any","clearTime","undefined","time","set","newTime","queueMicrotask","MotionValue","init","options","canTrackVelocity","events","updateAndNotify","v","currentTime","updatedAt","setPrevFrameValue","prev","current","setCurrent","change","dependents","dependent","dirty","hasAnimated","owner","value","isNaN","parseFloat","prevFrameValue","prevUpdatedAt","onChange","subscription","on","eventName","unsubscribe","stop","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","setWithVelocity","jump","endAnimation","addDependent","removeDependent","get","getPrevious","getVelocity","velocity","frameDuration","start","startAnimation","Promise","resolve","animation","animationStart","then","animationComplete","clearAnimation","animationCancel","isAnimating","destroy","createSelectorEffect","subjectEffect","subject","values","elements","elementOrSelector","EventTarget","document","querySelectorAll","Array","from","filter","element","resolveElements","remove","number","test","parse","transform","alpha","clamp","scale","default","int","round","createUnitType","unit","endsWith","split","degrees","percent","px","progressPercentage","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","width","maxWidth","height","maxHeight","top","right","bottom","left","inset","insetBlock","insetBlockStart","insetBlockEnd","insetInline","insetInlineStart","insetInlineEnd","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","paddingBlock","paddingBlockStart","paddingBlockEnd","paddingInline","paddingInlineStart","paddingInlineEnd","margin","marginTop","marginRight","marginBottom","marginLeft","marginBlock","marginBlockStart","marginBlockEnd","marginInline","marginInlineStart","marginInlineEnd","fontSize","backgroundPositionX","backgroundPositionY","rotate","pathRotation","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","x","y","z","perspective","transformPerspective","opacity","originX","originY","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","MotionValueState","latest","Map","name","computed","useDefaultValueType","existingValue","onRemove","type","getValueAsType","cancelOnChange","createEffect","addValue","stateCache","WeakMap","translateAlias","originProps","addStyleValue","isHTMLElement","style","transformIsDefault","valueIsDefault","startsWith","parsed","trim","buildTransform","transformOrigin","setProperty","styleEffect"],"mappings":"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"}