@windrun-huaiin/third-ui 14.2.0 → 14.3.1

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/easing/map-easing.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var linearEasing = require('../../../utils/supports/linear-easing.js');
+var linear = require('../utils/linear.js');
+var cubicBezier = require('./cubic-bezier.js');
+var supported = require('./supported.js');
+var isBezierDefinition = require('../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/utils/is-bezier-definition.js');
+
+function mapEasingToNativeEasing(easing, duration) {
+    if (!easing) {
+        return undefined;
+    }
+    else if (typeof easing === "function") {
+        return linearEasing.supportsLinearEasing()
+            ? linear.generateLinearEasing(easing, duration)
+            : "ease-out";
+    }
+    else if (isBezierDefinition.isBezierDefinition(easing)) {
+        return cubicBezier.cubicBezierAsString(easing);
+    }
+    else if (Array.isArray(easing)) {
+        return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) ||
+            supported.supportedWaapiEasing.easeOut);
+    }
+    else {
+        return supported.supportedWaapiEasing[easing];
+    }
+}
+
+exports.mapEasingToNativeEasing = mapEasingToNativeEasing;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/easing/map-easing.mjs

@@ -0,0 +1,28 @@
+import { supportsLinearEasing } from '../../../utils/supports/linear-easing.mjs';
+import { generateLinearEasing } from '../utils/linear.mjs';
+import { cubicBezierAsString } from './cubic-bezier.mjs';
+import { supportedWaapiEasing } from './supported.mjs';
+import { isBezierDefinition } from '../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/utils/is-bezier-definition.mjs';
+
+function mapEasingToNativeEasing(easing, duration) {
+    if (!easing) {
+        return undefined;
+    }
+    else if (typeof easing === "function") {
+        return supportsLinearEasing()
+            ? generateLinearEasing(easing, duration)
+            : "ease-out";
+    }
+    else if (isBezierDefinition(easing)) {
+        return cubicBezierAsString(easing);
+    }
+    else if (Array.isArray(easing)) {
+        return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) ||
+            supportedWaapiEasing.easeOut);
+    }
+    else {
+        return supportedWaapiEasing[easing];
+    }
+}
+
+export { mapEasingToNativeEasing };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/easing/supported.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var cubicBezier = require('./cubic-bezier.js');
+
+const supportedWaapiEasing = {
+    linear: "linear",
+    ease: "ease",
+    easeIn: "ease-in",
+    easeOut: "ease-out",
+    easeInOut: "ease-in-out",
+    circIn: /*@__PURE__*/ cubicBezier.cubicBezierAsString([0, 0.65, 0.55, 1]),
+    circOut: /*@__PURE__*/ cubicBezier.cubicBezierAsString([0.55, 0, 1, 0.45]),
+    backIn: /*@__PURE__*/ cubicBezier.cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),
+    backOut: /*@__PURE__*/ cubicBezier.cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),
+};
+
+exports.supportedWaapiEasing = supportedWaapiEasing;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/easing/supported.mjs

@@ -0,0 +1,15 @@
+import { cubicBezierAsString } from './cubic-bezier.mjs';
+
+const supportedWaapiEasing = {
+    linear: "linear",
+    ease: "ease",
+    easeIn: "ease-in",
+    easeOut: "ease-out",
+    easeInOut: "ease-in-out",
+    circIn: /*@__PURE__*/ cubicBezierAsString([0, 0.65, 0.55, 1]),
+    circOut: /*@__PURE__*/ cubicBezierAsString([0.55, 0, 1, 0.45]),
+    backIn: /*@__PURE__*/ cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),
+    backOut: /*@__PURE__*/ cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),
+};
+
+export { supportedWaapiEasing };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/start-waapi-animation.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var mapEasing = require('./easing/map-easing.js');
+
+function startWaapiAnimation(element, valueName, keyframes, { delay = 0, duration = 300, repeat = 0, repeatType = "loop", ease = "easeOut", times, } = {}, pseudoElement = undefined) {
+    const keyframeOptions = {
+        [valueName]: keyframes,
+    };
+    if (times)
+        keyframeOptions.offset = times;
+    const easing = mapEasing.mapEasingToNativeEasing(ease, duration);
+    /**
+     * If this is an easing array, apply to keyframes, not animation as a whole
+     */
+    if (Array.isArray(easing))
+        keyframeOptions.easing = easing;
+    const options = {
+        delay,
+        duration,
+        easing: !Array.isArray(easing) ? easing : "linear",
+        fill: "both",
+        iterations: repeat + 1,
+        direction: repeatType === "reverse" ? "alternate" : "normal",
+    };
+    if (pseudoElement)
+        options.pseudoElement = pseudoElement;
+    const animation = element.animate(keyframeOptions, options);
+    return animation;
+}
+
+exports.startWaapiAnimation = startWaapiAnimation;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/start-waapi-animation.mjs

@@ -0,0 +1,29 @@
+import { mapEasingToNativeEasing } from './easing/map-easing.mjs';
+
+function startWaapiAnimation(element, valueName, keyframes, { delay = 0, duration = 300, repeat = 0, repeatType = "loop", ease = "easeOut", times, } = {}, pseudoElement = undefined) {
+    const keyframeOptions = {
+        [valueName]: keyframes,
+    };
+    if (times)
+        keyframeOptions.offset = times;
+    const easing = mapEasingToNativeEasing(ease, duration);
+    /**
+     * If this is an easing array, apply to keyframes, not animation as a whole
+     */
+    if (Array.isArray(easing))
+        keyframeOptions.easing = easing;
+    const options = {
+        delay,
+        duration,
+        easing: !Array.isArray(easing) ? easing : "linear",
+        fill: "both",
+        iterations: repeat + 1,
+        direction: repeatType === "reverse" ? "alternate" : "normal",
+    };
+    if (pseudoElement)
+        options.pseudoElement = pseudoElement;
+    const animation = element.animate(keyframeOptions, options);
+    return animation;
+}
+
+export { startWaapiAnimation };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/supports/waapi.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var acceleratedValues = require('../utils/accelerated-values.js');
+var isBrowserColor = require('../utils/is-browser-color.js');
+var memo = require('../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/memo.js');
+
+const colorProperties = new Set([
+    "color",
+    "backgroundColor",
+    "outlineColor",
+    "fill",
+    "stroke",
+    "borderColor",
+    "borderTopColor",
+    "borderRightColor",
+    "borderBottomColor",
+    "borderLeftColor",
+]);
+const supportsWaapi = /*@__PURE__*/ memo.memo(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function supportsBrowserAnimation(options) {
+    const { motionValue, name, repeatDelay, repeatType, damping, type, keyframes, } = options;
+    const subject = motionValue?.owner?.current;
+    /**
+     * We use this check instead of isHTMLElement() because we explicitly
+     * **don't** want elements in different timing contexts (i.e. popups)
+     * to be accelerated, as it's not possible to sync these animations
+     * properly with those driven from the main window frameloop.
+     */
+    if (!(subject instanceof HTMLElement)) {
+        return false;
+    }
+    const { onUpdate, transformTemplate } = motionValue.owner.getProps();
+    return (supportsWaapi() &&
+        name &&
+        /**
+         * Force WAAPI for color properties with browser-only color formats
+         * (oklch, oklab, lab, lch, etc.) that the JS animation path can't parse.
+         */
+        (acceleratedValues.acceleratedValues.has(name) ||
+            (colorProperties.has(name) &&
+                isBrowserColor.hasBrowserOnlyColors(keyframes))) &&
+        (name !== "transform" || !transformTemplate) &&
+        /**
+         * If we're outputting values to onUpdate then we can't use WAAPI as there's
+         * no way to read the value from WAAPI every frame.
+         */
+        !onUpdate &&
+        !repeatDelay &&
+        repeatType !== "mirror" &&
+        damping !== 0 &&
+        type !== "inertia");
+}
+
+exports.supportsBrowserAnimation = supportsBrowserAnimation;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/supports/waapi.mjs

@@ -0,0 +1,52 @@
+import { acceleratedValues } from '../utils/accelerated-values.mjs';
+import { hasBrowserOnlyColors } from '../utils/is-browser-color.mjs';
+import { memo } from '../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/memo.mjs';
+
+const colorProperties = new Set([
+    "color",
+    "backgroundColor",
+    "outlineColor",
+    "fill",
+    "stroke",
+    "borderColor",
+    "borderTopColor",
+    "borderRightColor",
+    "borderBottomColor",
+    "borderLeftColor",
+]);
+const supportsWaapi = /*@__PURE__*/ memo(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function supportsBrowserAnimation(options) {
+    const { motionValue, name, repeatDelay, repeatType, damping, type, keyframes, } = options;
+    const subject = motionValue?.owner?.current;
+    /**
+     * We use this check instead of isHTMLElement() because we explicitly
+     * **don't** want elements in different timing contexts (i.e. popups)
+     * to be accelerated, as it's not possible to sync these animations
+     * properly with those driven from the main window frameloop.
+     */
+    if (!(subject instanceof HTMLElement)) {
+        return false;
+    }
+    const { onUpdate, transformTemplate } = motionValue.owner.getProps();
+    return (supportsWaapi() &&
+        name &&
+        /**
+         * Force WAAPI for color properties with browser-only color formats
+         * (oklch, oklab, lab, lch, etc.) that the JS animation path can't parse.
+         */
+        (acceleratedValues.has(name) ||
+            (colorProperties.has(name) &&
+                hasBrowserOnlyColors(keyframes))) &&
+        (name !== "transform" || !transformTemplate) &&
+        /**
+         * If we're outputting values to onUpdate then we can't use WAAPI as there's
+         * no way to read the value from WAAPI every frame.
+         */
+        !onUpdate &&
+        !repeatDelay &&
+        repeatType !== "mirror" &&
+        damping !== 0 &&
+        type !== "inertia");
+}
+
+export { supportsBrowserAnimation };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/accelerated-values.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * A list of values that can be hardware-accelerated.
+ */
+const acceleratedValues = new Set([
+    "opacity",
+    "clipPath",
+    "filter",
+    "transform",
+    // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
+    // or until we implement support for linear() easing.
+    // "background-color"
+]);
+
+exports.acceleratedValues = acceleratedValues;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/accelerated-values.mjs

@@ -0,0 +1,14 @@
+/**
+ * A list of values that can be hardware-accelerated.
+ */
+const acceleratedValues = new Set([
+    "opacity",
+    "clipPath",
+    "filter",
+    "transform",
+    // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
+    // or until we implement support for linear() easing.
+    // "background-color"
+]);
+
+export { acceleratedValues };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/apply-generator.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var linearEasing = require('../../../utils/supports/linear-easing.js');
+var isGenerator = require('../../generators/utils/is-generator.js');
+
+function applyGeneratorOptions({ type, ...options }) {
+    if (isGenerator.isGenerator(type) && linearEasing.supportsLinearEasing()) {
+        return type.applyToOptions(options);
+    }
+    else {
+        options.duration ?? (options.duration = 300);
+        options.ease ?? (options.ease = "easeOut");
+    }
+    return options;
+}
+
+exports.applyGeneratorOptions = applyGeneratorOptions;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/apply-generator.mjs

@@ -0,0 +1,15 @@
+import { supportsLinearEasing } from '../../../utils/supports/linear-easing.mjs';
+import { isGenerator } from '../../generators/utils/is-generator.mjs';
+
+function applyGeneratorOptions({ type, ...options }) {
+    if (isGenerator(type) && supportsLinearEasing()) {
+        return type.applyToOptions(options);
+    }
+    else {
+        options.duration ?? (options.duration = 300);
+        options.ease ?? (options.ease = "easeOut");
+    }
+    return options;
+}
+
+export { applyGeneratorOptions };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/is-browser-color.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const browserColorFunctions = /^(?:oklch|oklab|lab|lch|color|color-mix|light-dark)\(/;
+function hasBrowserOnlyColors(keyframes) {
+    for (let i = 0; i < keyframes.length; i++) {
+        if (typeof keyframes[i] === "string" &&
+            browserColorFunctions.test(keyframes[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+
+exports.hasBrowserOnlyColors = hasBrowserOnlyColors;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/is-browser-color.mjs

@@ -0,0 +1,12 @@
+const browserColorFunctions = /^(?:oklch|oklab|lab|lch|color|color-mix|light-dark)\(/;
+function hasBrowserOnlyColors(keyframes) {
+    for (let i = 0; i < keyframes.length; i++) {
+        if (typeof keyframes[i] === "string" &&
+            browserColorFunctions.test(keyframes[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export { hasBrowserOnlyColors };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/linear.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const generateLinearEasing = (easing, duration, // as milliseconds
+resolution = 10 // as milliseconds
+) => {
+    let points = "";
+    const numPoints = Math.max(Math.round(duration / resolution), 2);
+    for (let i = 0; i < numPoints; i++) {
+        points += Math.round(easing(i / (numPoints - 1)) * 10000) / 10000 + ", ";
+    }
+    return `linear(${points.substring(0, points.length - 2)})`;
+};
+
+exports.generateLinearEasing = generateLinearEasing;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/linear.mjs

@@ -0,0 +1,12 @@
+const generateLinearEasing = (easing, duration, // as milliseconds
+resolution = 10 // as milliseconds
+) => {
+    let points = "";
+    const numPoints = Math.max(Math.round(duration / resolution), 2);
+    for (let i = 0; i < numPoints; i++) {
+        points += Math.round(easing(i / (numPoints - 1)) * 10000) / 10000 + ", ";
+    }
+    return `linear(${points.substring(0, points.length - 2)})`;
+};
+
+export { generateLinearEasing };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/unsupported-easing.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var circ = require('../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/circ.js');
+var back = require('../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/back.js');
+var anticipate = require('../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/anticipate.js');
+
+const unsupportedEasingFunctions = {
+    anticipate: anticipate.anticipate,
+    backInOut: back.backInOut,
+    circInOut: circ.circInOut,
+};
+function isUnsupportedEase(key) {
+    return key in unsupportedEasingFunctions;
+}
+function replaceStringEasing(transition) {
+    if (typeof transition.ease === "string" &&
+        isUnsupportedEase(transition.ease)) {
+        transition.ease = unsupportedEasingFunctions[transition.ease];
+    }
+}
+
+exports.replaceStringEasing = replaceStringEasing;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/waapi/utils/unsupported-easing.mjs

@@ -0,0 +1,20 @@
+import { circInOut } from '../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/circ.mjs';
+import { backInOut } from '../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/back.mjs';
+import { anticipate } from '../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/anticipate.mjs';
+
+const unsupportedEasingFunctions = {
+    anticipate,
+    backInOut,
+    circInOut,
+};
+function isUnsupportedEase(key) {
+    return key in unsupportedEasingFunctions;
+}
+function replaceStringEasing(transition) {
+    if (typeof transition.ease === "string" &&
+        isUnsupportedEase(transition.ease)) {
+        transition.ease = unsupportedEasingFunctions[transition.ease];
+    }
+}
+
+export { replaceStringEasing };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/events/add-dom-event.js

@@ -0,0 +1,8 @@
+'use strict';
+
+function addDomEvent(target, eventName, handler, options = { passive: true }) {
+    target.addEventListener(eventName, handler, options);
+    return () => target.removeEventListener(eventName, handler);
+}
+
+exports.addDomEvent = addDomEvent;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/events/add-dom-event.mjs

@@ -0,0 +1,6 @@
+function addDomEvent(target, eventName, handler, options = { passive: true }) {
+    target.addEventListener(eventName, handler, options);
+    return () => target.removeEventListener(eventName, handler);
+}
+
+export { addDomEvent };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/batcher.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var order = require('./order.js');
+var renderStep = require('./render-step.js');
+var globalConfig = require('../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/global-config.js');
+
+const maxElapsed = 40;
+function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
+    let runNextFrame = false;
+    let useDefaultElapsed = true;
+    const state = {
+        delta: 0.0,
+        timestamp: 0.0,
+        isProcessing: false,
+    };
+    const flagRunNextFrame = () => (runNextFrame = true);
+    const steps = order.stepsOrder.reduce((acc, key) => {
+        acc[key] = renderStep.createRenderStep(flagRunNextFrame);
+        return acc;
+    }, {});
+    const { setup, read, resolveKeyframes, preUpdate, update, preRender, render, postRender, } = steps;
+    const processBatch = () => {
+        const useManualTiming = globalConfig.MotionGlobalConfig.useManualTiming;
+        const timestamp = useManualTiming
+            ? state.timestamp
+            : performance.now();
+        runNextFrame = false;
+        if (!useManualTiming) {
+            state.delta = useDefaultElapsed
+                ? 1000 / 60
+                : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
+        }
+        state.timestamp = timestamp;
+        state.isProcessing = true;
+        // Unrolled render loop for better per-frame performance
+        setup.process(state);
+        read.process(state);
+        resolveKeyframes.process(state);
+        preUpdate.process(state);
+        update.process(state);
+        preRender.process(state);
+        render.process(state);
+        postRender.process(state);
+        state.isProcessing = false;
+        if (runNextFrame && allowKeepAlive) {
+            useDefaultElapsed = false;
+            scheduleNextBatch(processBatch);
+        }
+    };
+    const wake = () => {
+        runNextFrame = true;
+        useDefaultElapsed = true;
+        if (!state.isProcessing) {
+            scheduleNextBatch(processBatch);
+        }
+    };
+    const schedule = order.stepsOrder.reduce((acc, key) => {
+        const step = steps[key];
+        acc[key] = (process, keepAlive = false, immediate = false) => {
+            if (!runNextFrame)
+                wake();
+            return step.schedule(process, keepAlive, immediate);
+        };
+        return acc;
+    }, {});
+    const cancel = (process) => {
+        for (let i = 0; i < order.stepsOrder.length; i++) {
+            steps[order.stepsOrder[i]].cancel(process);
+        }
+    };
+    return { schedule, cancel, state, steps };
+}
+
+exports.createRenderBatcher = createRenderBatcher;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/batcher.mjs

@@ -0,0 +1,72 @@
+import { stepsOrder } from './order.mjs';
+import { createRenderStep } from './render-step.mjs';
+import { MotionGlobalConfig } from '../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/global-config.mjs';
+
+const maxElapsed = 40;
+function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
+    let runNextFrame = false;
+    let useDefaultElapsed = true;
+    const state = {
+        delta: 0.0,
+        timestamp: 0.0,
+        isProcessing: false,
+    };
+    const flagRunNextFrame = () => (runNextFrame = true);
+    const steps = stepsOrder.reduce((acc, key) => {
+        acc[key] = createRenderStep(flagRunNextFrame);
+        return acc;
+    }, {});
+    const { setup, read, resolveKeyframes, preUpdate, update, preRender, render, postRender, } = steps;
+    const processBatch = () => {
+        const useManualTiming = MotionGlobalConfig.useManualTiming;
+        const timestamp = useManualTiming
+            ? state.timestamp
+            : performance.now();
+        runNextFrame = false;
+        if (!useManualTiming) {
+            state.delta = useDefaultElapsed
+                ? 1000 / 60
+                : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
+        }
+        state.timestamp = timestamp;
+        state.isProcessing = true;
+        // Unrolled render loop for better per-frame performance
+        setup.process(state);
+        read.process(state);
+        resolveKeyframes.process(state);
+        preUpdate.process(state);
+        update.process(state);
+        preRender.process(state);
+        render.process(state);
+        postRender.process(state);
+        state.isProcessing = false;
+        if (runNextFrame && allowKeepAlive) {
+            useDefaultElapsed = false;
+            scheduleNextBatch(processBatch);
+        }
+    };
+    const wake = () => {
+        runNextFrame = true;
+        useDefaultElapsed = true;
+        if (!state.isProcessing) {
+            scheduleNextBatch(processBatch);
+        }
+    };
+    const schedule = stepsOrder.reduce((acc, key) => {
+        const step = steps[key];
+        acc[key] = (process, keepAlive = false, immediate = false) => {
+            if (!runNextFrame)
+                wake();
+            return step.schedule(process, keepAlive, immediate);
+        };
+        return acc;
+    }, {});
+    const cancel = (process) => {
+        for (let i = 0; i < stepsOrder.length; i++) {
+            steps[stepsOrder[i]].cancel(process);
+        }
+    };
+    return { schedule, cancel, state, steps };
+}
+
+export { createRenderBatcher };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/frame.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var batcher = require('./batcher.js');
+var noop = require('../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/noop.js');
+
+const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps, } = /* @__PURE__ */ batcher.createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop.noop, true);
+
+exports.cancelFrame = cancelFrame;
+exports.frame = frame;
+exports.frameData = frameData;
+exports.frameSteps = frameSteps;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/frame.mjs

@@ -0,0 +1,6 @@
+import { createRenderBatcher } from './batcher.mjs';
+import { noop } from '../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/noop.mjs';
+
+const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps, } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop, true);
+
+export { cancelFrame, frame, frameData, frameSteps };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/microtask.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var batcher = require('./batcher.js');
+
+const { schedule: microtask} = 
+/* @__PURE__ */ batcher.createRenderBatcher(queueMicrotask, false);
+
+exports.microtask = microtask;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/microtask.mjs

@@ -0,0 +1,6 @@
+import { createRenderBatcher } from './batcher.mjs';
+
+const { schedule: microtask} = 
+/* @__PURE__ */ createRenderBatcher(queueMicrotask, false);
+
+export { microtask };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/order.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const stepsOrder = [
+    "setup", // Compute
+    "read", // Read
+    "resolveKeyframes", // Write/Read/Write/Read
+    "preUpdate", // Compute
+    "update", // Compute
+    "preRender", // Compute
+    "render", // Write
+    "postRender", // Compute
+];
+
+exports.stepsOrder = stepsOrder;