flikkui 0.1.0-beta.11 → 0.1.0-beta.12

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/get-final.js

@@ -1,11 +0,0 @@
-const isNotNull = (value) => value !== null;
-function getFinalKeyframe(keyframes, { repeat, repeatType = "loop" }, finalKeyframe, speed = 1) {
-    const resolvedKeyframes = keyframes.filter(isNotNull);
-    const useFirstKeyframe = speed < 0 || (repeat && repeatType !== "loop" && repeat % 2 === 1);
-    const index = useFirstKeyframe ? 0 : resolvedKeyframes.length - 1;
-    return !index || finalKeyframe === undefined
-        ? resolvedKeyframes[index]
-        : finalKeyframe;
-}
-
-export { getFinalKeyframe };

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/default.js

@@ -1,9 +0,0 @@
-import { fillOffset } from './fill.js';
-
-function defaultOffset(arr) {
-    const offset = [0];
-    fillOffset(offset, arr.length - 1);
-    return offset;
-}
-
-export { defaultOffset };

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.js

@@ -1,12 +0,0 @@
-import { mixNumber } from '../../../utils/mix/number.js';
-import { progress } from '../../../../../../motion-utils/dist/es/progress.js';
-
-function fillOffset(offset, remaining) {
-    const min = offset[offset.length - 1];
-    for (let i = 1; i <= remaining; i++) {
-        const offsetProgress = progress(0, remaining, i);
-        offset.push(mixNumber(min, 1, offsetProgress));
-    }
-}
-
-export { fillOffset };

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/time.js

@@ -1,5 +0,0 @@
-function convertOffsetToTimes(offset, duration) {
-    return offset.map((o) => o * duration);
-}
-
-export { convertOffsetToTimes };

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/fill-wildcards.js

@@ -1,7 +0,0 @@
-function fillWildcards(keyframes) {
-    for (let i = 1; i < keyframes.length; i++) {
-        keyframes[i] ?? (keyframes[i] = keyframes[i - 1]);
-    }
-}
-
-export { fillWildcards };

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/is-none.js

@@ -1,15 +0,0 @@
-import { isZeroValueString } from '../../../../../../motion-utils/dist/es/is-zero-value-string.js';
-
-function isNone(value) {
-    if (typeof value === "number") {
-        return value === 0;
-    }
-    else if (value !== null) {
-        return value === "none" || value === "0" || isZeroValueString(value);
-    }
-    else {
-        return true;
-    }
-}
-
-export { isNone };

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/make-none-animatable.js

@@ -1,30 +0,0 @@
-import { analyseComplexValue } from '../../../value/types/complex/index.js';
-import { getAnimatableNone } from '../../../value/types/utils/animatable-none.js';
-
-/**
- * If we encounter keyframes like "none" or "0" and we also have keyframes like
- * "#fff" or "200px 200px" we want to find a keyframe to serve as a template for
- * the "none" keyframes. In this case "#fff" or "200px 200px" - then these get turned into
- * zero equivalents, i.e. "#fff0" or "0px 0px".
- */
-const invalidTemplates = new Set(["auto", "none", "0"]);
-function makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {
-    let i = 0;
-    let animatableTemplate = undefined;
-    while (i < unresolvedKeyframes.length && !animatableTemplate) {
-        const keyframe = unresolvedKeyframes[i];
-        if (typeof keyframe === "string" &&
-            !invalidTemplates.has(keyframe) &&
-            analyseComplexValue(keyframe).values.length) {
-            animatableTemplate = unresolvedKeyframes[i];
-        }
-        i++;
-    }
-    if (animatableTemplate && name) {
-        for (const noneIndex of noneKeyframeIndexes) {
-            unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);
-        }
-    }
-}
-
-export { makeNoneKeyframesAnimatable };

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/unit-conversion.js

@@ -1,36 +0,0 @@
-import { parseValueFromTransform } from '../../../render/dom/parse-transform.js';
-import { transformPropOrder } from '../../../render/utils/keys-transform.js';
-import { number } from '../../../value/types/numbers/index.js';
-import { px } from '../../../value/types/numbers/units.js';
-
-const isNumOrPxType = (v) => v === number || v === px;
-const transformKeys = new Set(["x", "y", "z"]);
-const nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));
-function removeNonTranslationalTransform(visualElement) {
-    const removedTransforms = [];
-    nonTranslationalTransformKeys.forEach((key) => {
-        const value = visualElement.getValue(key);
-        if (value !== undefined) {
-            removedTransforms.push([key, value.get()]);
-            value.set(key.startsWith("scale") ? 1 : 0);
-        }
-    });
-    return removedTransforms;
-}
-const positionalValues = {
-    // Dimensions
-    width: ({ x }, { paddingLeft = "0", paddingRight = "0" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),
-    height: ({ y }, { paddingTop = "0", paddingBottom = "0" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),
-    top: (_bbox, { top }) => parseFloat(top),
-    left: (_bbox, { left }) => parseFloat(left),
-    bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),
-    right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),
-    // Transform
-    x: (_bbox, { transform }) => parseValueFromTransform(transform, "x"),
-    y: (_bbox, { transform }) => parseValueFromTransform(transform, "y"),
-};
-// Alias translate longform names
-positionalValues.translateX = positionalValues.x;
-positionalValues.translateY = positionalValues.y;
-
-export { isNumOrPxType, positionalValues, removeNonTranslationalTransform };

package/dist/node_modules/motion-dom/dist/es/animation/utils/WithPromise.js

@@ -1,26 +0,0 @@
-class WithPromise {
-    constructor() {
-        this.updateFinished();
-    }
-    get finished() {
-        return this._finished;
-    }
-    updateFinished() {
-        this._finished = new Promise((resolve) => {
-            this.resolve = resolve;
-        });
-    }
-    notifyFinished() {
-        this.resolve();
-    }
-    /**
-     * Allows the animation to be awaited.
-     *
-     * @deprecated Use `finished` instead.
-     */
-    then(onResolve, onReject) {
-        return this.finished.then(onResolve, onReject);
-    }
-}
-
-export { WithPromise };

package/dist/node_modules/motion-dom/dist/es/animation/utils/can-animate.js

@@ -1,42 +0,0 @@
-import { isGenerator } from '../generators/utils/is-generator.js';
-import { isAnimatable } from './is-animatable.js';
-import { warning } from '../../../../../motion-utils/dist/es/errors.js';
-
-function hasKeyframesChanged(keyframes) {
-    const current = keyframes[0];
-    if (keyframes.length === 1)
-        return true;
-    for (let i = 0; i < keyframes.length; i++) {
-        if (keyframes[i] !== current)
-            return true;
-    }
-}
-function canAnimate(keyframes, name, type, velocity) {
-    /**
-     * Check if we're able to animate between the start and end keyframes,
-     * and throw a warning if we're attempting to animate between one that's
-     * animatable and another that isn't.
-     */
-    const originKeyframe = keyframes[0];
-    if (originKeyframe === null)
-        return false;
-    /**
-     * These aren't traditionally animatable but we do support them.
-     * In future we could look into making this more generic or replacing
-     * this function with mix() === mixImmediate
-     */
-    if (name === "display" || name === "visibility")
-        return true;
-    const targetKeyframe = keyframes[keyframes.length - 1];
-    const isOriginAnimatable = isAnimatable(originKeyframe, name);
-    const isTargetAnimatable = isAnimatable(targetKeyframe, name);
-    warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} from "${originKeyframe}" to "${targetKeyframe}". "${isOriginAnimatable ? targetKeyframe : originKeyframe}" is not an animatable value.`, "value-not-animatable");
-    // Always skip if any of these are true
-    if (!isOriginAnimatable || !isTargetAnimatable) {
-        return false;
-    }
-    return (hasKeyframesChanged(keyframes) ||
-        ((type === "spring" || isGenerator(type)) && velocity));
-}
-
-export { canAnimate };

package/dist/node_modules/motion-dom/dist/es/animation/utils/css-variables-conversion.js

@@ -1,42 +0,0 @@
-import { isCSSVariableToken } from './is-css-variable.js';
-import { invariant } from '../../../../../motion-utils/dist/es/errors.js';
-import { isNumericalString } from '../../../../../motion-utils/dist/es/is-numerical-string.js';
-
-/**
- * Parse Framer's special CSS variable format into a CSS token and a fallback.
- *
- * ```
- * `var(--foo, #fff)` => [`--foo`, '#fff']
- * ```
- *
- * @param current
- */
-const splitCSSVariableRegex = 
-// eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words
-/^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u;
-function parseCSSVariable(current) {
-    const match = splitCSSVariableRegex.exec(current);
-    if (!match)
-        return [,];
-    const [, token1, token2, fallback] = match;
-    return [`--${token1 ?? token2}`, fallback];
-}
-const maxDepth = 4;
-function getVariableValue(current, element, depth = 1) {
-    invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property "${current}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
-    const [token, fallback] = parseCSSVariable(current);
-    // No CSS variable detected
-    if (!token)
-        return;
-    // Attempt to read this CSS variable off the element
-    const resolved = window.getComputedStyle(element).getPropertyValue(token);
-    if (resolved) {
-        const trimmed = resolved.trim();
-        return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;
-    }
-    return isCSSVariableToken(fallback)
-        ? getVariableValue(fallback, element, depth + 1)
-        : fallback;
-}
-
-export { getVariableValue, parseCSSVariable };

package/dist/node_modules/motion-dom/dist/es/animation/utils/get-value-transition.js

@@ -1,7 +0,0 @@
-function getValueTransition(transition, key) {
-    return (transition?.[key] ??
-        transition?.["default"] ??
-        transition);
-}
-
-export { getValueTransition };

package/dist/node_modules/motion-dom/dist/es/animation/utils/is-animatable.js

@@ -1,30 +0,0 @@
-import { complex } from '../../value/types/complex/index.js';
-
-/**
- * Check if a value is animatable. Examples:
- *
- * ✅: 100, "100px", "#fff"
- * ❌: "block", "url(2.jpg)"
- * @param value
- *
- * @internal
- */
-const isAnimatable = (value, name) => {
-    // If the list of keys that might be non-animatable grows, replace with Set
-    if (name === "zIndex")
-        return false;
-    // If it's a number or a keyframes array, we can animate it. We might at some point
-    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,
-    // but for now lets leave it like this for performance reasons
-    if (typeof value === "number" || Array.isArray(value))
-        return true;
-    if (typeof value === "string" && // It's animatable if we have a string
-        (complex.test(value) || value === "0") && // And it contains numbers and/or colors
-        !value.startsWith("url(") // Unless it starts with "url("
-    ) {
-        return true;
-    }
-    return false;
-};
-
-export { isAnimatable };

package/dist/node_modules/motion-dom/dist/es/animation/utils/is-css-variable.js

@@ -1,15 +0,0 @@
-const checkStringStartsWith = (token) => (key) => typeof key === "string" && key.startsWith(token);
-const isCSSVariableName = 
-/*@__PURE__*/ checkStringStartsWith("--");
-const startsAsVariableToken = 
-/*@__PURE__*/ checkStringStartsWith("var(--");
-const isCSSVariableToken = (value) => {
-    const startsWithToken = startsAsVariableToken(value);
-    if (!startsWithToken)
-        return false;
-    // Ensure any comments are stripped from the value as this can harm performance of the regex.
-    return singleCssVariableRegex.test(value.split("/*")[0].trim());
-};
-const singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
-
-export { isCSSVariableName, isCSSVariableToken };

package/dist/node_modules/motion-dom/dist/es/animation/utils/make-animation-instant.js

@@ -1,6 +0,0 @@
-function makeAnimationInstant(options) {
-    options.duration = 0;
-    options.type === "keyframes";
-}
-
-export { makeAnimationInstant };

package/dist/node_modules/motion-dom/dist/es/animation/utils/replace-transition-type.js

@@ -1,18 +0,0 @@
-import { inertia } from '../generators/inertia.js';
-import { keyframes } from '../generators/keyframes.js';
-import { spring } from '../generators/spring/index.js';
-
-const transitionTypeMap = {
-    decay: inertia,
-    inertia,
-    tween: keyframes,
-    keyframes: keyframes,
-    spring,
-};
-function replaceTransitionType(transition) {
-    if (typeof transition.type === "string") {
-        transition.type = transitionTypeMap[transition.type];
-    }
-}
-
-export { replaceTransitionType };

package/dist/node_modules/motion-dom/dist/es/animation/waapi/easing/cubic-bezier.js

@@ -1,3 +0,0 @@
-const cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;
-
-export { cubicBezierAsString };

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

@@ -1,28 +0,0 @@
-import { supportsLinearEasing } from '../../../utils/supports/linear-easing.js';
-import { generateLinearEasing } from '../utils/linear.js';
-import { cubicBezierAsString } from './cubic-bezier.js';
-import { supportedWaapiEasing } from './supported.js';
-import { isBezierDefinition } from '../../../../../../motion-utils/dist/es/easing/utils/is-bezier-definition.js';
-
-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/motion-dom/dist/es/animation/waapi/easing/supported.js

@@ -1,15 +0,0 @@
-import { cubicBezierAsString } from './cubic-bezier.js';
-
-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/motion-dom/dist/es/animation/waapi/start-waapi-animation.js

@@ -1,29 +0,0 @@
-import { mapEasingToNativeEasing } from './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 = 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/motion-dom/dist/es/animation/waapi/supports/waapi.js

@@ -1,43 +0,0 @@
-import { memo } from '../../../../../../motion-utils/dist/es/memo.js';
-
-/**
- * A list of values that can be hardware-accelerated.
- */
-const acceleratedValues = new Set([
-    "opacity",
-    "clipPath",
-    "filter",
-    "transform",
-    // TODO: Could be re-enabled now we have support for linear() easing
-    // "background-color"
-]);
-const supportsWaapi = /*@__PURE__*/ memo(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
-function supportsBrowserAnimation(options) {
-    const { motionValue, name, repeatDelay, repeatType, damping, type } = 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 &&
-        acceleratedValues.has(name) &&
-        (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/motion-dom/dist/es/animation/waapi/utils/apply-generator.js

@@ -1,15 +0,0 @@
-import { supportsLinearEasing } from '../../../utils/supports/linear-easing.js';
-import { isGenerator } from '../../generators/utils/is-generator.js';
-
-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/motion-dom/dist/es/animation/waapi/utils/linear.js

@@ -1,12 +0,0 @@
-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/motion-dom/dist/es/animation/waapi/utils/unsupported-easing.js

@@ -1,20 +0,0 @@
-import { circInOut } from '../../../../../../motion-utils/dist/es/easing/circ.js';
-import { backInOut } from '../../../../../../motion-utils/dist/es/easing/back.js';
-import { anticipate } from '../../../../../../motion-utils/dist/es/easing/anticipate.js';
-
-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/motion-dom/dist/es/frameloop/batcher.js

@@ -1,71 +0,0 @@
-import { stepsOrder } from './order.js';
-import { createRenderStep } from './render-step.js';
-import { MotionGlobalConfig } from '../../../../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 = stepsOrder.reduce((acc, key) => {
-        acc[key] = createRenderStep(flagRunNextFrame);
-        return acc;
-    }, {});
-    const { setup, read, resolveKeyframes, preUpdate, update, preRender, render, postRender, } = steps;
-    const processBatch = () => {
-        const timestamp = MotionGlobalConfig.useManualTiming
-            ? state.timestamp
-            : performance.now();
-        runNextFrame = false;
-        if (!MotionGlobalConfig.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/motion-dom/dist/es/frameloop/frame.js

@@ -1,6 +0,0 @@
-import { createRenderBatcher } from './batcher.js';
-import { noop } from '../../../../motion-utils/dist/es/noop.js';
-
-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/motion-dom/dist/es/frameloop/microtask.js

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

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

@@ -1,12 +0,0 @@
-const stepsOrder = [
-    "setup", // Compute
-    "read", // Read
-    "resolveKeyframes", // Write/Read/Write/Read
-    "preUpdate", // Compute
-    "update", // Compute
-    "preRender", // Compute
-    "render", // Write
-    "postRender", // Compute
-];
-
-export { stepsOrder };