motion 12.18.0 → 12.18.2

package/dist/es/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs

@@ -1,17 +0,0 @@
-/**
- * Implement a practical max duration for keyframe generation
- * to prevent infinite loops
- */
-const maxGeneratorDuration = 20000;
-function calcGeneratorDuration(generator) {
-    let duration = 0;
-    const timeStep = 50;
-    let state = generator.next(duration);
-    while (!state.done && duration < maxGeneratorDuration) {
-        duration += timeStep;
-        state = generator.next(duration);
-    }
-    return duration >= maxGeneratorDuration ? Infinity : duration;
-}
-
-export { calcGeneratorDuration, maxGeneratorDuration };

package/dist/es/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs

@@ -1,19 +0,0 @@
-import { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';
-import { millisecondsToSeconds } from '../../../../../../motion-utils/dist/es/time-conversion.mjs';
-
-/**
- * Create a progress => progress easing function from a generator.
- */
-function createGeneratorEasing(options, scale = 100, createGenerator) {
-    const generator = createGenerator({ ...options, keyframes: [0, scale] });
-    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
-    return {
-        type: "keyframes",
-        ease: (progress) => {
-            return generator.next(duration * progress).value / scale;
-        },
-        duration: millisecondsToSeconds(duration),
-    };
-}
-
-export { createGeneratorEasing };

package/dist/es/motion-dom/dist/es/animation/generators/utils/is-generator.mjs

@@ -1,5 +0,0 @@
-function isGenerator(type) {
-    return typeof type === "function" && "applyToOptions" in type;
-}
-
-export { isGenerator };

package/dist/es/motion-dom/dist/es/animation/generators/utils/velocity.mjs

@@ -1,9 +0,0 @@
-import { velocityPerSecond } from '../../../../../../motion-utils/dist/es/velocity-per-second.mjs';
-
-const velocitySampleDuration = 5; // ms
-function calcGeneratorVelocity(resolveValue, t, current) {
-    const prevT = Math.max(t - velocitySampleDuration, 0);
-    return velocityPerSecond(current - resolveValue(prevT), t - prevT);
-}
-
-export { calcGeneratorVelocity };

package/dist/es/motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.mjs

@@ -1,131 +0,0 @@
-import { positionalKeys } from '../../render/utils/keys-position.mjs';
-import { findDimensionValueType } from '../../value/types/dimensions.mjs';
-import { getVariableValue } from '../utils/css-variables-conversion.mjs';
-import { isCSSVariableToken } from '../utils/is-css-variable.mjs';
-import { KeyframeResolver } from './KeyframesResolver.mjs';
-import { isNone } from './utils/is-none.mjs';
-import { makeNoneKeyframesAnimatable } from './utils/make-none-animatable.mjs';
-import { isNumOrPxType, positionalValues } from './utils/unit-conversion.mjs';
-
-class DOMKeyframesResolver extends KeyframeResolver {
-    constructor(unresolvedKeyframes, onComplete, name, motionValue, element) {
-        super(unresolvedKeyframes, onComplete, name, motionValue, element, true);
-    }
-    readKeyframes() {
-        const { unresolvedKeyframes, element, name } = this;
-        if (!element || !element.current)
-            return;
-        super.readKeyframes();
-        /**
-         * If any keyframe is a CSS variable, we need to find its value by sampling the element
-         */
-        for (let i = 0; i < unresolvedKeyframes.length; i++) {
-            let keyframe = unresolvedKeyframes[i];
-            if (typeof keyframe === "string") {
-                keyframe = keyframe.trim();
-                if (isCSSVariableToken(keyframe)) {
-                    const resolved = getVariableValue(keyframe, element.current);
-                    if (resolved !== undefined) {
-                        unresolvedKeyframes[i] = resolved;
-                    }
-                    if (i === unresolvedKeyframes.length - 1) {
-                        this.finalKeyframe = keyframe;
-                    }
-                }
-            }
-        }
-        /**
-         * Resolve "none" values. We do this potentially twice - once before and once after measuring keyframes.
-         * This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which
-         * have a far bigger performance impact.
-         */
-        this.resolveNoneKeyframes();
-        /**
-         * Check to see if unit type has changed. If so schedule jobs that will
-         * temporarily set styles to the destination keyframes.
-         * Skip if we have more than two keyframes or this isn't a positional value.
-         * TODO: We can throw if there are multiple keyframes and the value type changes.
-         */
-        if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {
-            return;
-        }
-        const [origin, target] = unresolvedKeyframes;
-        const originType = findDimensionValueType(origin);
-        const targetType = findDimensionValueType(target);
-        /**
-         * Either we don't recognise these value types or we can animate between them.
-         */
-        if (originType === targetType)
-            return;
-        /**
-         * If both values are numbers or pixels, we can animate between them by
-         * converting them to numbers.
-         */
-        if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {
-            for (let i = 0; i < unresolvedKeyframes.length; i++) {
-                const value = unresolvedKeyframes[i];
-                if (typeof value === "string") {
-                    unresolvedKeyframes[i] = parseFloat(value);
-                }
-            }
-        }
-        else if (positionalValues[name]) {
-            /**
-             * Else, the only way to resolve this is by measuring the element.
-             */
-            this.needsMeasurement = true;
-        }
-    }
-    resolveNoneKeyframes() {
-        const { unresolvedKeyframes, name } = this;
-        const noneKeyframeIndexes = [];
-        for (let i = 0; i < unresolvedKeyframes.length; i++) {
-            if (unresolvedKeyframes[i] === null ||
-                isNone(unresolvedKeyframes[i])) {
-                noneKeyframeIndexes.push(i);
-            }
-        }
-        if (noneKeyframeIndexes.length) {
-            makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);
-        }
-    }
-    measureInitialState() {
-        const { element, unresolvedKeyframes, name } = this;
-        if (!element || !element.current)
-            return;
-        if (name === "height") {
-            this.suspendedScrollY = window.pageYOffset;
-        }
-        this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
-        unresolvedKeyframes[0] = this.measuredOrigin;
-        // Set final key frame to measure after next render
-        const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
-        if (measureKeyframe !== undefined) {
-            element.getValue(name, measureKeyframe).jump(measureKeyframe, false);
-        }
-    }
-    measureEndState() {
-        const { element, name, unresolvedKeyframes } = this;
-        if (!element || !element.current)
-            return;
-        const value = element.getValue(name);
-        value && value.jump(this.measuredOrigin, false);
-        const finalKeyframeIndex = unresolvedKeyframes.length - 1;
-        const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];
-        unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
-        if (finalKeyframe !== null && this.finalKeyframe === undefined) {
-            this.finalKeyframe = finalKeyframe;
-        }
-        // If we removed transform values, reapply them before the next render
-        if (this.removedTransforms?.length) {
-            this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {
-                element
-                    .getValue(unsetTransformName)
-                    .set(unsetTransformValue);
-            });
-        }
-        this.resolveNoneKeyframes();
-    }
-}
-
-export { DOMKeyframesResolver };

package/dist/es/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs

@@ -1,147 +0,0 @@
-import { fillWildcards } from './utils/fill-wildcards.mjs';
-import { removeNonTranslationalTransform } from './utils/unit-conversion.mjs';
-import { frame } from '../../frameloop/frame.mjs';
-
-const toResolve = new Set();
-let isScheduled = false;
-let anyNeedsMeasurement = false;
-let isForced = false;
-function measureAllKeyframes() {
-    if (anyNeedsMeasurement) {
-        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);
-        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));
-        const transformsToRestore = new Map();
-        /**
-         * Write pass
-         * If we're measuring elements we want to remove bounding box-changing transforms.
-         */
-        elementsToMeasure.forEach((element) => {
-            const removedTransforms = removeNonTranslationalTransform(element);
-            if (!removedTransforms.length)
-                return;
-            transformsToRestore.set(element, removedTransforms);
-            element.render();
-        });
-        // Read
-        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());
-        // Write
-        elementsToMeasure.forEach((element) => {
-            element.render();
-            const restore = transformsToRestore.get(element);
-            if (restore) {
-                restore.forEach(([key, value]) => {
-                    element.getValue(key)?.set(value);
-                });
-            }
-        });
-        // Read
-        resolversToMeasure.forEach((resolver) => resolver.measureEndState());
-        // Write
-        resolversToMeasure.forEach((resolver) => {
-            if (resolver.suspendedScrollY !== undefined) {
-                window.scrollTo(0, resolver.suspendedScrollY);
-            }
-        });
-    }
-    anyNeedsMeasurement = false;
-    isScheduled = false;
-    toResolve.forEach((resolver) => resolver.complete(isForced));
-    toResolve.clear();
-}
-function readAllKeyframes() {
-    toResolve.forEach((resolver) => {
-        resolver.readKeyframes();
-        if (resolver.needsMeasurement) {
-            anyNeedsMeasurement = true;
-        }
-    });
-}
-function flushKeyframeResolvers() {
-    isForced = true;
-    readAllKeyframes();
-    measureAllKeyframes();
-    isForced = false;
-}
-class KeyframeResolver {
-    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {
-        this.state = "pending";
-        /**
-         * Track whether this resolver is async. If it is, it'll be added to the
-         * resolver queue and flushed in the next frame. Resolvers that aren't going
-         * to trigger read/write thrashing don't need to be async.
-         */
-        this.isAsync = false;
-        /**
-         * Track whether this resolver needs to perform a measurement
-         * to resolve its keyframes.
-         */
-        this.needsMeasurement = false;
-        this.unresolvedKeyframes = [...unresolvedKeyframes];
-        this.onComplete = onComplete;
-        this.name = name;
-        this.motionValue = motionValue;
-        this.element = element;
-        this.isAsync = isAsync;
-    }
-    scheduleResolve() {
-        this.state = "scheduled";
-        if (this.isAsync) {
-            toResolve.add(this);
-            if (!isScheduled) {
-                isScheduled = true;
-                frame.read(readAllKeyframes);
-                frame.resolveKeyframes(measureAllKeyframes);
-            }
-        }
-        else {
-            this.readKeyframes();
-            this.complete();
-        }
-    }
-    readKeyframes() {
-        const { unresolvedKeyframes, name, element, motionValue } = this;
-        // If initial keyframe is null we need to read it from the DOM
-        if (unresolvedKeyframes[0] === null) {
-            const currentValue = motionValue?.get();
-            // TODO: This doesn't work if the final keyframe is a wildcard
-            const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
-            if (currentValue !== undefined) {
-                unresolvedKeyframes[0] = currentValue;
-            }
-            else if (element && name) {
-                const valueAsRead = element.readValue(name, finalKeyframe);
-                if (valueAsRead !== undefined && valueAsRead !== null) {
-                    unresolvedKeyframes[0] = valueAsRead;
-                }
-            }
-            if (unresolvedKeyframes[0] === undefined) {
-                unresolvedKeyframes[0] = finalKeyframe;
-            }
-            if (motionValue && currentValue === undefined) {
-                motionValue.set(unresolvedKeyframes[0]);
-            }
-        }
-        fillWildcards(unresolvedKeyframes);
-    }
-    setFinalKeyframe() { }
-    measureInitialState() { }
-    renderEndStyles() { }
-    measureEndState() { }
-    complete(isForcedComplete = false) {
-        this.state = "complete";
-        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, isForcedComplete);
-        toResolve.delete(this);
-    }
-    cancel() {
-        if (this.state === "scheduled") {
-            toResolve.delete(this);
-            this.state = "pending";
-        }
-    }
-    resume() {
-        if (this.state === "pending")
-            this.scheduleResolve();
-    }
-}
-
-export { KeyframeResolver, flushKeyframeResolvers };

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

@@ -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/es/motion-dom/dist/es/animation/keyframes/offsets/default.mjs

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

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

@@ -1,12 +0,0 @@
-import { mixNumber } from '../../../utils/mix/number.mjs';
-import { progress } from '../../../../../../motion-utils/dist/es/progress.mjs';
-
-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/es/motion-dom/dist/es/animation/keyframes/offsets/time.mjs

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

package/dist/es/motion-dom/dist/es/animation/keyframes/utils/apply-px-defaults.mjs

@@ -1,11 +0,0 @@
-import { pxValues } from '../../waapi/utils/px-values.mjs';
-
-function applyPxDefaults(keyframes, name) {
-    for (let i = 0; i < keyframes.length; i++) {
-        if (typeof keyframes[i] === "number" && pxValues.has(name)) {
-            keyframes[i] = keyframes[i] + "px";
-        }
-    }
-}
-
-export { applyPxDefaults };

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

@@ -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/es/motion-dom/dist/es/animation/keyframes/utils/is-none.mjs

@@ -1,15 +0,0 @@
-import { isZeroValueString } from '../../../../../../motion-utils/dist/es/is-zero-value-string.mjs';
-
-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/es/motion-dom/dist/es/animation/keyframes/utils/make-none-animatable.mjs

@@ -1,30 +0,0 @@
-import { analyseComplexValue } from '../../../value/types/complex/index.mjs';
-import { getAnimatableNone } from '../../../value/types/utils/animatable-none.mjs';
-
-/**
- * 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/es/motion-dom/dist/es/animation/keyframes/utils/unit-conversion.mjs

@@ -1,36 +0,0 @@
-import { parseValueFromTransform } from '../../../render/dom/parse-transform.mjs';
-import { transformPropOrder } from '../../../render/utils/keys-transform.mjs';
-import { number } from '../../../value/types/numbers/index.mjs';
-import { px } from '../../../value/types/numbers/units.mjs';
-
-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/es/motion-dom/dist/es/animation/utils/WithPromise.mjs

@@ -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/es/motion-dom/dist/es/animation/utils/active-animations.mjs

@@ -1,9 +0,0 @@
-const animationMaps = new WeakMap();
-const animationMapKey = (name, pseudoElement = "") => `${name}:${pseudoElement}`;
-function getAnimationMap(element) {
-    const map = animationMaps.get(element) || new Map();
-    animationMaps.set(element, map);
-    return map;
-}
-
-export { animationMapKey, getAnimationMap };

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

@@ -1,42 +0,0 @@
-import { isGenerator } from '../generators/utils/is-generator.mjs';
-import { isAnimatable } from './is-animatable.mjs';
-import { warning } from '../../../../../motion-utils/dist/es/errors.mjs';
-
-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}". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \`style\` property.`);
-    // 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/es/motion-dom/dist/es/animation/utils/css-variables-conversion.mjs

@@ -1,42 +0,0 @@
-import { isCSSVariableToken } from './is-css-variable.mjs';
-import { invariant } from '../../../../../motion-utils/dist/es/errors.mjs';
-import { isNumericalString } from '../../../../../motion-utils/dist/es/is-numerical-string.mjs';
-
-/**
- * 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.`);
-    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/es/motion-dom/dist/es/animation/utils/get-value-transition.mjs

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

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

@@ -1,30 +0,0 @@
-import { complex } from '../../value/types/complex/index.mjs';
-
-/**
- * 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 tat 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/es/motion-dom/dist/es/animation/utils/is-css-variable.mjs

@@ -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 };