{"version":3,"file":"size-rollup-style-effect.js","sources":["../lib/animation/waapi/transforms/groups.js","../lib/render/dom/is-css-var.js","../lib/render/dom/parse-transform.js","../lib/render/utils/keys-transform.js","../../motion-utils/dist/es/clamp.mjs","../../motion-utils/dist/es/global-config.mjs","../../motion-utils/dist/es/is-object.mjs","../../motion-utils/dist/es/subscription-manager.mjs","../../motion-utils/dist/es/array.mjs","../lib/utils/is-html-element.js","../lib/frameloop/order.js","../lib/frameloop/batcher.js","../lib/frameloop/render-step.js","../lib/frameloop/frame-data.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/value/types/numbers/index.js","../lib/value/types/int.js","../lib/value/types/numbers/units.js","../lib/value/types/maps/transform.js","../lib/value/types/maps/number.js","../lib/value/types/utils/get-as-type.js","../lib/effects/utils/create-dom-effect.js","../lib/utils/resolve-elements.js","../lib/effects/MotionValueState.js","../lib/effects/utils/create-effect.js","../lib/render/html/utils/build-transform.js","../lib/effects/style/transform.js","../lib/effects/style/index.js","../lib/utils/is-svg-element.js"],"sourcesContent":["export const transformGroups = new WeakMap();\n//# sourceMappingURL=groups.js.map","export const isCSSVar = (name) => name.startsWith(\"--\");\n//# sourceMappingURL=is-css-var.js.map","const radToDeg = (rad) => (rad * 180) / Math.PI;\nconst rotate = (v) => {\n    const angle = radToDeg(Math.atan2(v[1], v[0]));\n    return rebaseAngle(angle);\n};\nconst matrix2dParsers = {\n    x: 4,\n    y: 5,\n    translateX: 4,\n    translateY: 5,\n    scaleX: 0,\n    scaleY: 3,\n    scaleZ: () => 1,\n    scale: (v) => (Math.abs(v[0]) + Math.abs(v[3])) / 2,\n    rotate,\n    rotateZ: rotate,\n    skewX: (v) => radToDeg(Math.atan(v[1])),\n    skewY: (v) => radToDeg(Math.atan(v[2])),\n    skew: (v) => (Math.abs(v[1]) + Math.abs(v[2])) / 2,\n};\nconst rebaseAngle = (angle) => {\n    angle = angle % 360;\n    if (angle < 0)\n        angle += 360;\n    return angle;\n};\nconst rotateZ = rotate;\nconst scaleX = (v) => Math.hypot(v[0], v[1]);\nconst scaleY = (v) => Math.hypot(v[4], v[5]);\nconst matrix3dParsers = {\n    x: 12,\n    y: 13,\n    z: 14,\n    translateX: 12,\n    translateY: 13,\n    translateZ: 14,\n    scaleX,\n    scaleY,\n    scaleZ: (v) => Math.hypot(v[8], v[9], v[10]),\n    scale: (v) => (scaleX(v) + scaleY(v)) / 2,\n    rotateX: (v) => rebaseAngle(radToDeg(Math.atan2(v[6], v[5]))),\n    rotateY: (v) => rebaseAngle(radToDeg(Math.atan2(-v[2], v[0]))),\n    rotateZ,\n    rotate: rotateZ,\n    skewX: (v) => radToDeg(Math.atan(v[4])),\n    skewY: (v) => radToDeg(Math.atan(v[1])),\n    skew: (v) => (Math.abs(v[1]) + Math.abs(v[4])) / 2,\n};\nexport function defaultTransformValue(name) {\n    return name.includes(\"scale\") ? 1 : 0;\n}\nexport function parseValueFromTransform(transform, name) {\n    if (!transform || transform === \"none\") {\n        return defaultTransformValue(name);\n    }\n    const matrix3dMatch = transform.match(/^matrix3d\\(([-\\d.e\\s,]+)\\)$/u);\n    let parsers;\n    let match;\n    if (matrix3dMatch) {\n        parsers = matrix3dParsers;\n        match = matrix3dMatch;\n    }\n    else {\n        const matrix2dMatch = transform.match(/^matrix\\(([-\\d.e\\s,]+)\\)$/u);\n        parsers = matrix2dParsers;\n        match = matrix2dMatch;\n    }\n    if (!match) {\n        return defaultTransformValue(name);\n    }\n    const valueParser = parsers[name];\n    const values = match[1].split(\",\").map(convertTransformToNumber);\n    return typeof valueParser === \"function\"\n        ? valueParser(values)\n        : values[valueParser];\n}\nexport const readTransformValue = (instance, name) => {\n    const { transform = \"none\" } = getComputedStyle(instance);\n    return parseValueFromTransform(transform, name);\n};\nfunction convertTransformToNumber(value) {\n    return parseFloat(value.trim());\n}\n//# sourceMappingURL=parse-transform.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    \"scaleZ\",\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","const isObject = (value) => typeof value === \"object\" && value !== null;\n\nexport { isObject };\n//# sourceMappingURL=is-object.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 () => this.remove(handler);\n    }\n    remove(handler) {\n        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","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","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, state = {\n    delta: 0.0,\n    timestamp: 0.0,\n    isProcessing: false,\n}) {\n    let runNextFrame = false;\n    let useDefaultElapsed = true;\n    const flagRunNextFrame = () => (runNextFrame = true);\n    const steps = stepsOrder.reduce((acc, key) => {\n        acc[key] = createRenderStep(flagRunNextFrame);\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","export function createRenderStep(runNextFrame) {\n    /**\n     * We create and reuse two queues, one to queue jobs for the current frame\n     * and one for the next. We reuse to avoid triggering GC after x frames.\n     */\n    let thisFrame = new 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     * A keepAlive process is always also held by a frame queue until\n     * it's cancelled, so a Set has the same lifetime semantics as a\n     * WeakSet here while being considerably faster to query every frame.\n     */\n    const toKeepAlive = new Set();\n    let latestFrameData = {\n        delta: 0.0,\n        timestamp: 0.0,\n        isProcessing: false,\n    };\n    function triggerCallback(callback) {\n        if (toKeepAlive.has(callback)) {\n            nextFrame.add(callback);\n            runNextFrame();\n        }\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            // 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","/**\n * The frameloop's state, kept apart from the frameloop itself so that\n * reading it doesn't bundle the scheduler.\n */\nexport const frameData = {\n    delta: 0.0,\n    timestamp: 0.0,\n    isProcessing: false,\n};\n//# sourceMappingURL=frame-data.js.map","import { noop } from \"motion-utils\";\nimport { createRenderBatcher } from \"./batcher\";\nimport { frameData } from \"./frame-data\";\nexport const { schedule: frame, cancel: cancelFrame, steps: frameSteps, } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== \"undefined\" ? requestAnimationFrame : noop, true, frameData);\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-data\";\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.notifyChange();\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        var _a;\n        if (eventName === \"change\")\n            return this.onChangeSubscribe(callback);\n        return ((_a = this.events)[eventName] || (_a[eventName] = new SubscriptionManager())).add(callback);\n    }\n    onChangeSubscribe(callback) {\n        const { events } = this;\n        if (!events.change && !this.changeSubscriber) {\n            this.changeSubscriber = callback;\n        }\n        else {\n            if (!events.change) {\n                events.change = new SubscriptionManager();\n                events.change.add(this.changeSubscriber);\n                this.changeSubscriber = undefined;\n            }\n            events.change.add(callback);\n        }\n        return () => {\n            if (this.changeSubscriber === callback) {\n                this.changeSubscriber = undefined;\n            }\n            else {\n                events.change?.remove(callback);\n            }\n            this.stopIfUnobserved();\n        };\n    }\n    /**\n     * If we have no more change listeners by the start\n     * of the next frame, stop active animations.\n     */\n    stopIfUnobserved() {\n        frame.read(() => {\n            if (!this.changeSubscriber && !this.events.change?.getSize()) {\n                this.stop();\n            }\n        });\n    }\n    clearListeners() {\n        this.changeSubscriber = undefined;\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.notifyChange();\n    }\n    notifyChange() {\n        const { current, changeSubscriber } = this;\n        /**\n         * One or the other exists. Subscribing during the direct\n         * subscriber's call moves it into a new manager, which must not\n         * then be notified for the same change.\n         */\n        if (changeSubscriber) {\n            changeSubscriber(current);\n        }\n        else {\n            this.events.change?.notify(current);\n        }\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        /**\n         * A value animating on the compositor isn't updated every frame,\n         * so read it from its animation.\n         */\n        const sampled = this.animation?.liveValue?.();\n        return sampled === undefined ? this.current : sampled;\n    }\n    /**\n     * The value as last set. Unlike get(), this doesn't read an animation\n     * running on the compositor, which renders the value itself.\n     */\n    getCurrent() {\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            /**\n             * Complete synchronously via the callback rather than chaining a\n             * second promise per animation. Guard against animations that\n             * complete before startAnimation has returned.\n             */\n            let isComplete = false;\n            let animation;\n            // eslint-disable-next-line prefer-const -- read by the callback before assignment when completing synchronously\n            animation = startAnimation(() => {\n                isComplete = true;\n                this.events.animationComplete?.notify();\n                if (this.animation === animation)\n                    this.clearAnimation();\n                resolve();\n            });\n            if (!isComplete)\n                this.animation = animation;\n            this.events.animationStart?.notify();\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        // Assign rather than delete to keep the object's shape stable\n        this.animation = undefined;\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 { 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 { 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 { 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","/**\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 { resolveElements, } from \"../../utils/resolve-elements\";\nexport function createSelectorEffect(subjectEffect) {\n    const effect = (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    const { test, read, get, flush, state } = subjectEffect;\n    return Object.assign(effect, {\n        test,\n        read,\n        get: get,\n        flush,\n        state,\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 { frame } from \"../frameloop/frame\";\nexport class MotionValueState {\n    /**\n     * @param step - The frameloop step renders are scheduled in. Defaults\n     * to `frame.render`. Effects that feed a render loop running in\n     * `frame.render` (GPU scenes) should write in `frame.preRender`.\n     */\n    constructor(step = frame.render) {\n        this.step = step;\n        this.values = new Map();\n        /**\n         * Renders scheduled for the next flush, usually one or two (values\n         * bound to the same computed render, e.g. `x` and `y` to `transform`,\n         * share an entry). Tracked with a count rather than truncating the\n         * array so no backing store is reallocated every frame. Kept per\n         * state so pending writes can be flushed synchronously before the\n         * subject is measured.\n         */\n        this.pending = [];\n        this.numPending = 0;\n        /**\n         * Run the pending renders. Resetting the count first means a render\n         * scheduled while flushing lands in the next frame, as with the\n         * frameloop itself.\n         */\n        this.flush = () => {\n            const { pending, numPending } = this;\n            this.numPending = 0;\n            for (let i = 0; i < numPending; i++)\n                pending[i]();\n        };\n    }\n    /**\n     * @param render - Writes the value to the subject. Renders read the\n     * motion value directly rather than a cached copy, so there is one\n     * place a value lives.\n     * @param computed - A value already in this state (e.g. `transform`)\n     * whose render should run whenever `value` changes.\n     */\n    set(name, value, render, computed) {\n        this.values.get(name)?.onRemove();\n        if (computed) {\n            for (const entry of this.values.values()) {\n                if (entry.value === computed)\n                    render = entry.render;\n            }\n        }\n        const onChange = () => render && this.schedule(render);\n        /**\n         * Values created ahead of a DOM read start out undefined and\n         * have nothing to render until they're set.\n         */\n        value.get() !== undefined && onChange();\n        const cancelOnChange = value.on(\"change\", onChange);\n        const onRemove = () => {\n            cancelOnChange();\n            render && !computed && this.cancel(render);\n            /**\n             * A later set() of the same name has already removed this\n             * entry, so leave the one that replaced it.\n             */\n            this.values.get(name)?.onRemove === onRemove &&\n                this.values.delete(name);\n        };\n        this.values.set(name, {\n            value,\n            render: computed ? undefined : render,\n            onRemove,\n        });\n        return onRemove;\n    }\n    get(name) {\n        return this.values.get(name)?.value;\n    }\n    /**\n     * Detach every value from this state and return them, so another\n     * renderer can take them over. The state stays cached by its effect,\n     * so the bound transforms are reset too rather than leaking into\n     * values bound later.\n     */\n    release() {\n        const values = new Map();\n        this.values.forEach((entry, name) => {\n            values.set(name, entry.value);\n            entry.onRemove();\n        });\n        this.transformKeys = this.transformValues = undefined;\n        return values;\n    }\n    schedule(render) {\n        const { pending, numPending } = this;\n        for (let i = 0; i < numPending; i++) {\n            if (pending[i] === render)\n                return;\n        }\n        numPending || this.step(this.flush);\n        pending[this.numPending++] = render;\n    }\n    cancel(render) {\n        const { pending } = this;\n        for (let i = 0; i < this.numPending; i++) {\n            if (pending[i] === render) {\n                pending[i] = pending[--this.numPending];\n                return;\n            }\n        }\n    }\n}\n//# sourceMappingURL=MotionValueState.js.map","import { MotionValueState } from \"../MotionValueState\";\nexport function createEffect(addValue, { step, ...options } = {}) {\n    const stateCache = new WeakMap();\n    const effect = (subject, values) => {\n        const state = stateCache.get(subject) ?? new MotionValueState(step);\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    return Object.assign(effect, options, {\n        get: (subject, key) => stateCache.get(subject)?.get(key),\n        flush: (subject) => stateCache.get(subject)?.flush(),\n        state: (subject) => stateCache.get(subject),\n    });\n}\n//# sourceMappingURL=create-effect.js.map","import { getValueAsType } from \"../../../value/types/utils/get-as-type\";\nimport { numberValueTypes } from \"../../../value/types/maps/number\";\nimport { transformPropOrder } from \"../../utils/keys-transform\";\nexport const translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\nconst numTransforms = transformPropOrder.length;\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nexport function buildTransform(latestValues, transform, transformTemplate) {\n    // The transform string we're going to build into.\n    let transformString = \"\";\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 < numTransforms; i++) {\n        const key = transformPropOrder[i];\n        const value = latestValues[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 || transformTemplate) {\n            const valueAsType = getValueAsType(value, numberValueTypes[key]);\n            if (!valueIsDefault) {\n                transformIsDefault = false;\n                const transformName = translateAlias[key] || key;\n                transformString += `${transformName}(${valueAsType}) `;\n            }\n            if (transformTemplate) {\n                transform[key] = valueAsType;\n            }\n        }\n    }\n    // `pathRotation` composes onto `rotate` as a separate additive term so\n    // the user's `rotate` is never clobbered. Deliberately not a slot in\n    // `transformPropOrder`.\n    const pathRotation = latestValues.pathRotation;\n    if (pathRotation) {\n        transformIsDefault = false;\n        transformString += `rotate(${getValueAsType(pathRotation, numberValueTypes.pathRotation)}) `;\n    }\n    transformString = transformString.trim();\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n//# sourceMappingURL=build-transform.js.map","import { translateAlias } from \"../../render/html/utils/build-transform\";\nimport { transformValueTypes } from \"../../value/types/maps/transform\";\nimport { getValueAsType } from \"../../value/types/utils/get-as-type\";\n/**\n * Cache of `translateX(`-style openers so each render is a few string\n * concatenations rather than a template per transform.\n */\nconst openers = {};\nexport function buildTransform(state) {\n    let transform = \"\";\n    const { transformKeys: keys = [], transformValues: values = {} } = state;\n    /**\n     * Loop over the bound transforms in order, adding the ones that\n     * aren't at their default value to the transform string.\n     */\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        const value = values[key].getCurrent();\n        if (value === undefined)\n            continue;\n        const parsed = typeof value === \"number\" ? value : parseFloat(value);\n        if (parsed !== (key.startsWith(\"scale\") ? 1 : 0)) {\n            transform +=\n                (transform && \" \") +\n                    (openers[key] ||\n                        (openers[key] = (translateAlias[key] || key) + \"(\")) +\n                    getValueAsType(value, transformValueTypes[key]) +\n                    \")\";\n        }\n    }\n    // See build-transform.ts: additive `rotate()` so user `rotate` isn't\n    // clobbered. Not a `transformPropOrder` slot.\n    const pathRotation = state.get(\"pathRotation\")?.get();\n    if (pathRotation) {\n        transform +=\n            (transform && \" \") +\n                \"rotate(\" +\n                getValueAsType(pathRotation, transformValueTypes.pathRotation) +\n                \")\";\n    }\n    return transform || \"none\";\n}\n//# sourceMappingURL=transform.js.map","import { transformGroups } from \"../../animation/waapi/transforms/groups\";\nimport { isCSSVar } from \"../../render/dom/is-css-var\";\nimport { readTransformValue } from \"../../render/dom/parse-transform\";\nimport { transformPropOrder, transformProps, } from \"../../render/utils/keys-transform\";\nimport { isHTMLElement } from \"../../utils/is-html-element\";\nimport { isSVGElement } from \"../../utils/is-svg-element\";\nimport { MotionValue } from \"../../value\";\nimport { numberValueTypes } from \"../../value/types/maps/number\";\nimport { getValueAsType } from \"../../value/types/utils/get-as-type\";\nimport { createSelectorEffect } from \"../utils/create-dom-effect\";\nimport { createEffect } from \"../utils/create-effect\";\nimport { buildTransform } from \"./transform\";\nexport const originProps = new Set([\"originX\", \"originY\", \"originZ\"]);\n/**\n * A bound value in its default unit, e.g. `originX: 50` -> `\"50%\"`.\n */\nconst styleValue = (state, key) => getValueAsType(state.get(key)?.get(), numberValueTypes[key]);\nexport const addStyleValue = (element, state, key, value) => {\n    let render = undefined;\n    let computed = undefined;\n    if (transformProps.has(key)) {\n        if (key !== \"pathRotation\") {\n            const keys = (state.transformKeys ?? (state.transformKeys = []));\n            (state.transformValues ?? (state.transformValues = {}))[key] = value;\n            if (!keys.includes(key)) {\n                keys.push(key);\n                keys.sort((a, b) => transformPropOrder.indexOf(a) -\n                    transformPropOrder.indexOf(b));\n            }\n        }\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                transformGroups.get(element)?.check();\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 = styleValue(state, \"originX\") ?? \"50%\";\n                const originY = styleValue(state, \"originY\") ?? \"50%\";\n                const originZ = styleValue(state, \"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, value.getCurrent());\n        };\n    }\n    else {\n        render = () => {\n            element.style[key] = getValueAsType(value.getCurrent(), numberValueTypes[key]);\n        };\n    }\n    return state.set(key, value, render, computed);\n};\nconst isStyleSubject = (subject) => isHTMLElement(subject) || isSVGElement(subject);\n/**\n * Reads the current value of a style from the element, as the initial\n * keyframe when `animate()` targets an element via this effect. Transforms\n * are parsed out of the computed matrix; everything else is the computed\n * style. Units aren't converted to match the target keyframes. A style\n * the browser can't report is 0, as a VisualElement reports it.\n */\nexport const readStyleValue = (element, key) => {\n    if (transformProps.has(key)) {\n        return readTransformValue(element, key);\n    }\n    const computedStyle = getComputedStyle(element);\n    const value = isCSSVar(key)\n        ? computedStyle.getPropertyValue(key)\n        : computedStyle[key];\n    return (typeof value === \"string\" && value.trim()) || 0;\n};\n/**\n * The per-element effect `animate()` binds through, so HTML values share\n * state with a direct `styleEffect()` call. The exported `styleEffect`\n * is this wrapped to also accept selectors.\n */\nexport const styleSubjectEffect = /*@__PURE__*/ createEffect(addStyleValue, {\n    test: isStyleSubject,\n    read: readStyleValue,\n});\nexport const styleEffect = \n/*@__PURE__*/ createSelectorEffect(styleSubjectEffect);\n//# sourceMappingURL=index.js.map","import { isObject } from \"motion-utils\";\n/**\n * Checks if an element is an SVG element in a way\n * that works across iframes\n */\nexport function isSVGElement(element) {\n    return isObject(element) && \"ownerSVGElement\" in element;\n}\n//# sourceMappingURL=is-svg-element.js.map"],"names":["transformGroups","WeakMap","isCSSVar","name","startsWith","radToDeg","rad","Math","PI","rotate","v","angle","atan2","rebaseAngle","matrix2dParsers","x","y","translateX","translateY","scaleX","scaleY","scaleZ","scale","abs","rotateZ","skewX","atan","skewY","skew","hypot","matrix3dParsers","z","translateZ","rotateX","rotateY","defaultTransformValue","includes","readTransformValue","instance","transform","getComputedStyle","matrix3dMatch","match","parsers","matrix2dMatch","valueParser","values","split","map","convertTransformToNumber","parseValueFromTransform","value","parseFloat","trim","transformPropOrder","transformProps","Set","MotionGlobalConfig","isObject","SubscriptionManager","constructor","this","subscriptions","add","handler","arr","item","indexOf","push","remove","index","splice","removeItem","notify","a","b","c","numSubscriptions","length","i","getSize","clear","isHTMLElement","element","stepsOrder","createRenderBatcher","scheduleNextBatch","allowKeepAlive","state","delta","timestamp","isProcessing","runNextFrame","useDefaultElapsed","flagRunNextFrame","steps","reduce","acc","key","thisFrame","nextFrame","flushNextFrame","toKeepAlive","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","max","min","frame","requestAnimationFrame","any","clearTime","undefined","time","set","newTime","queueMicrotask","MotionValue","init","options","canTrackVelocity","events","updateAndNotify","currentTime","updatedAt","setPrevFrameValue","prev","current","setCurrent","notifyChange","dependents","dependent","dirty","hasAnimated","owner","isNaN","prevFrameValue","prevUpdatedAt","onChange","subscription","on","eventName","_a","onChangeSubscribe","change","changeSubscriber","stopIfUnobserved","stop","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","setWithVelocity","jump","endAnimation","addDependent","removeDependent","get","sampled","animation","liveValue","getCurrent","getPrevious","getVelocity","velocity","frameDuration","start","startAnimation","Promise","resolve","isComplete","animationComplete","clearAnimation","animationStart","animationCancel","isAnimating","destroy","number","test","parse","alpha","clamp","default","int","round","createUnitType","unit","endsWith","degrees","percent","px","progressPercentage","transformValueTypes","pathRotation","distance","perspective","transformPerspective","opacity","originX","originY","originZ","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","zIndex","fillOpacity","strokeOpacity","numOctaves","getValueAsType","type","createSelectorEffect","subjectEffect","flush","Object","assign","subject","elements","elementOrSelector","EventTarget","document","querySelectorAll","Array","from","filter","resolveElements","MotionValueState","Map","pending","numPending","computed","onRemove","entry","cancelOnChange","release","transformKeys","transformValues","createEffect","addValue","stateCache","translateAlias","openers","originProps","styleValue","addStyleValue","keys","sort","check","style","buildTransform","transformOrigin","setProperty","readStyleValue","computedStyle","getPropertyValue","styleSubjectEffect","styleEffect"],"mappings":"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"}