@windrun-huaiin/third-ui 14.2.0 → 14.3.0

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/node/state.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * This should only ever be modified on the client otherwise it'll
+ * persist through server requests. If we need instanced states we
+ * could lazy-init via root.
+ */
+const globalProjectionState = {
+    /**
+     * Global flag as to whether the tree has animated since the last time
+     * we resized the window
+     */
+    hasAnimatedSinceResize: true,
+    /**
+     * We set this to true once, on the first update. Any nodes added to the tree beyond that
+     * update will be given a `data-projection-id` attribute.
+     */
+    hasEverUpdated: false,
+};
+
+exports.globalProjectionState = globalProjectionState;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/node/state.mjs

@@ -0,0 +1,19 @@
+/**
+ * This should only ever be modified on the client otherwise it'll
+ * persist through server requests. If we need instanced states we
+ * could lazy-init via root.
+ */
+const globalProjectionState = {
+    /**
+     * Global flag as to whether the tree has animated since the last time
+     * we resized the window
+     */
+    hasAnimatedSinceResize: true,
+    /**
+     * We set this to true once, on the first update. Any nodes added to the tree beyond that
+     * update will be given a `data-projection-id` attribute.
+     */
+    hasEverUpdated: false,
+};
+
+export { globalProjectionState };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/shared/stack.js

@@ -0,0 +1,86 @@
+'use strict';
+
+var array = require('../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/array.js');
+
+class NodeStack {
+    constructor() {
+        this.members = [];
+    }
+    add(node) {
+        array.addUniqueItem(this.members, node);
+        for (let i = this.members.length - 1; i >= 0; i--) {
+            const member = this.members[i];
+            if (member === node || member === this.lead || member === this.prevLead)
+                continue;
+            const inst = member.instance;
+            if ((!inst || inst.isConnected === false) && !member.snapshot) {
+                array.removeItem(this.members, member);
+                member.unmount();
+            }
+        }
+        node.scheduleRender();
+    }
+    remove(node) {
+        array.removeItem(this.members, node);
+        if (node === this.prevLead)
+            this.prevLead = undefined;
+        if (node === this.lead) {
+            const prevLead = this.members[this.members.length - 1];
+            if (prevLead)
+                this.promote(prevLead);
+        }
+    }
+    relegate(node) {
+        for (let i = this.members.indexOf(node) - 1; i >= 0; i--) {
+            const member = this.members[i];
+            if (member.isPresent !== false && member.instance?.isConnected !== false) {
+                this.promote(member);
+                return true;
+            }
+        }
+        return false;
+    }
+    promote(node, preserveFollowOpacity) {
+        const prevLead = this.lead;
+        if (node === prevLead)
+            return;
+        this.prevLead = prevLead;
+        this.lead = node;
+        node.show();
+        if (prevLead) {
+            prevLead.updateSnapshot();
+            node.scheduleRender();
+            const { layoutDependency: prevDep } = prevLead.options;
+            const { layoutDependency: nextDep } = node.options;
+            if (prevDep === undefined || prevDep !== nextDep) {
+                node.resumeFrom = prevLead;
+                if (preserveFollowOpacity)
+                    prevLead.preserveOpacity = true;
+                if (prevLead.snapshot) {
+                    node.snapshot = prevLead.snapshot;
+                    node.snapshot.latestValues =
+                        prevLead.animationValues || prevLead.latestValues;
+                }
+                if (node.root?.isUpdating)
+                    node.isLayoutDirty = true;
+            }
+            if (node.options.crossfade === false)
+                prevLead.hide();
+        }
+    }
+    exitAnimationComplete() {
+        this.members.forEach((member) => {
+            member.options.onExitComplete?.();
+            member.resumingFrom?.options.onExitComplete?.();
+        });
+    }
+    scheduleRender() {
+        this.members.forEach((member) => member.instance && member.scheduleRender(false));
+    }
+    removeLeadSnapshot() {
+        if (this.lead?.snapshot)
+            this.lead.snapshot = undefined;
+    }
+}
+
+exports.NodeStack = NodeStack;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/shared/stack.mjs

@@ -0,0 +1,84 @@
+import { addUniqueItem, removeItem } from '../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/array.mjs';
+
+class NodeStack {
+    constructor() {
+        this.members = [];
+    }
+    add(node) {
+        addUniqueItem(this.members, node);
+        for (let i = this.members.length - 1; i >= 0; i--) {
+            const member = this.members[i];
+            if (member === node || member === this.lead || member === this.prevLead)
+                continue;
+            const inst = member.instance;
+            if ((!inst || inst.isConnected === false) && !member.snapshot) {
+                removeItem(this.members, member);
+                member.unmount();
+            }
+        }
+        node.scheduleRender();
+    }
+    remove(node) {
+        removeItem(this.members, node);
+        if (node === this.prevLead)
+            this.prevLead = undefined;
+        if (node === this.lead) {
+            const prevLead = this.members[this.members.length - 1];
+            if (prevLead)
+                this.promote(prevLead);
+        }
+    }
+    relegate(node) {
+        for (let i = this.members.indexOf(node) - 1; i >= 0; i--) {
+            const member = this.members[i];
+            if (member.isPresent !== false && member.instance?.isConnected !== false) {
+                this.promote(member);
+                return true;
+            }
+        }
+        return false;
+    }
+    promote(node, preserveFollowOpacity) {
+        const prevLead = this.lead;
+        if (node === prevLead)
+            return;
+        this.prevLead = prevLead;
+        this.lead = node;
+        node.show();
+        if (prevLead) {
+            prevLead.updateSnapshot();
+            node.scheduleRender();
+            const { layoutDependency: prevDep } = prevLead.options;
+            const { layoutDependency: nextDep } = node.options;
+            if (prevDep === undefined || prevDep !== nextDep) {
+                node.resumeFrom = prevLead;
+                if (preserveFollowOpacity)
+                    prevLead.preserveOpacity = true;
+                if (prevLead.snapshot) {
+                    node.snapshot = prevLead.snapshot;
+                    node.snapshot.latestValues =
+                        prevLead.animationValues || prevLead.latestValues;
+                }
+                if (node.root?.isUpdating)
+                    node.isLayoutDirty = true;
+            }
+            if (node.options.crossfade === false)
+                prevLead.hide();
+        }
+    }
+    exitAnimationComplete() {
+        this.members.forEach((member) => {
+            member.options.onExitComplete?.();
+            member.resumingFrom?.options.onExitComplete?.();
+        });
+    }
+    scheduleRender() {
+        this.members.forEach((member) => member.instance && member.scheduleRender(false));
+    }
+    removeLeadSnapshot() {
+        if (this.lead?.snapshot)
+            this.lead.snapshot = undefined;
+    }
+}
+
+export { NodeStack };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/styles/scale-border-radius.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var units = require('../../value/types/numbers/units.js');
+
+function pixelsToPercent(pixels, axis) {
+    if (axis.max === axis.min)
+        return 0;
+    return (pixels / (axis.max - axis.min)) * 100;
+}
+/**
+ * We always correct borderRadius as a percentage rather than pixels to reduce paints.
+ * For example, if you are projecting a box that is 100px wide with a 10px borderRadius
+ * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%
+ * borderRadius in both states. If we animate between the two in pixels that will trigger
+ * a paint each time. If we animate between the two in percentage we'll avoid a paint.
+ */
+const correctBorderRadius = {
+    correct: (latest, node) => {
+        if (!node.target)
+            return latest;
+        /**
+         * If latest is a string, if it's a percentage we can return immediately as it's
+         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.
+         */
+        if (typeof latest === "string") {
+            if (units.px.test(latest)) {
+                latest = parseFloat(latest);
+            }
+            else {
+                return latest;
+            }
+        }
+        /**
+         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that
+         * pixel value as a percentage of each axis
+         */
+        const x = pixelsToPercent(latest, node.target.x);
+        const y = pixelsToPercent(latest, node.target.y);
+        return `${x}% ${y}%`;
+    },
+};
+
+exports.correctBorderRadius = correctBorderRadius;
+exports.pixelsToPercent = pixelsToPercent;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/styles/scale-border-radius.mjs

@@ -0,0 +1,41 @@
+import { px } from '../../value/types/numbers/units.mjs';
+
+function pixelsToPercent(pixels, axis) {
+    if (axis.max === axis.min)
+        return 0;
+    return (pixels / (axis.max - axis.min)) * 100;
+}
+/**
+ * We always correct borderRadius as a percentage rather than pixels to reduce paints.
+ * For example, if you are projecting a box that is 100px wide with a 10px borderRadius
+ * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%
+ * borderRadius in both states. If we animate between the two in pixels that will trigger
+ * a paint each time. If we animate between the two in percentage we'll avoid a paint.
+ */
+const correctBorderRadius = {
+    correct: (latest, node) => {
+        if (!node.target)
+            return latest;
+        /**
+         * If latest is a string, if it's a percentage we can return immediately as it's
+         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.
+         */
+        if (typeof latest === "string") {
+            if (px.test(latest)) {
+                latest = parseFloat(latest);
+            }
+            else {
+                return latest;
+            }
+        }
+        /**
+         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that
+         * pixel value as a percentage of each axis
+         */
+        const x = pixelsToPercent(latest, node.target.x);
+        const y = pixelsToPercent(latest, node.target.y);
+        return `${x}% ${y}%`;
+    },
+};
+
+export { correctBorderRadius, pixelsToPercent };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/styles/scale-box-shadow.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var index = require('../../value/types/complex/index.js');
+var number = require('../../utils/mix/number.js');
+
+const correctBoxShadow = {
+    correct: (latest, { treeScale, projectionDelta }) => {
+        const original = latest;
+        const shadow = index.complex.parse(latest);
+        // TODO: Doesn't support multiple shadows
+        if (shadow.length > 5)
+            return original;
+        const template = index.complex.createTransformer(latest);
+        const offset = typeof shadow[0] !== "number" ? 1 : 0;
+        // Calculate the overall context scale
+        const xScale = projectionDelta.x.scale * treeScale.x;
+        const yScale = projectionDelta.y.scale * treeScale.y;
+        shadow[0 + offset] /= xScale;
+        shadow[1 + offset] /= yScale;
+        /**
+         * Ideally we'd correct x and y scales individually, but because blur and
+         * spread apply to both we have to take a scale average and apply that instead.
+         * We could potentially improve the outcome of this by incorporating the ratio between
+         * the two scales.
+         */
+        const averageScale = number.mixNumber(xScale, yScale, 0.5);
+        // Blur
+        if (typeof shadow[2 + offset] === "number")
+            shadow[2 + offset] /= averageScale;
+        // Spread
+        if (typeof shadow[3 + offset] === "number")
+            shadow[3 + offset] /= averageScale;
+        return template(shadow);
+    },
+};
+
+exports.correctBoxShadow = correctBoxShadow;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/styles/scale-box-shadow.mjs

@@ -0,0 +1,35 @@
+import { complex } from '../../value/types/complex/index.mjs';
+import { mixNumber } from '../../utils/mix/number.mjs';
+
+const correctBoxShadow = {
+    correct: (latest, { treeScale, projectionDelta }) => {
+        const original = latest;
+        const shadow = complex.parse(latest);
+        // TODO: Doesn't support multiple shadows
+        if (shadow.length > 5)
+            return original;
+        const template = complex.createTransformer(latest);
+        const offset = typeof shadow[0] !== "number" ? 1 : 0;
+        // Calculate the overall context scale
+        const xScale = projectionDelta.x.scale * treeScale.x;
+        const yScale = projectionDelta.y.scale * treeScale.y;
+        shadow[0 + offset] /= xScale;
+        shadow[1 + offset] /= yScale;
+        /**
+         * Ideally we'd correct x and y scales individually, but because blur and
+         * spread apply to both we have to take a scale average and apply that instead.
+         * We could potentially improve the outcome of this by incorporating the ratio between
+         * the two scales.
+         */
+        const averageScale = mixNumber(xScale, yScale, 0.5);
+        // Blur
+        if (typeof shadow[2 + offset] === "number")
+            shadow[2 + offset] /= averageScale;
+        // Spread
+        if (typeof shadow[3 + offset] === "number")
+            shadow[3 + offset] /= averageScale;
+        return template(shadow);
+    },
+};
+
+export { correctBoxShadow };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/styles/scale-correction.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var scaleBorderRadius = require('./scale-border-radius.js');
+var scaleBoxShadow = require('./scale-box-shadow.js');
+
+const scaleCorrectors = {
+    borderRadius: {
+        ...scaleBorderRadius.correctBorderRadius,
+        applyTo: [
+            "borderTopLeftRadius",
+            "borderTopRightRadius",
+            "borderBottomLeftRadius",
+            "borderBottomRightRadius",
+        ],
+    },
+    borderTopLeftRadius: scaleBorderRadius.correctBorderRadius,
+    borderTopRightRadius: scaleBorderRadius.correctBorderRadius,
+    borderBottomLeftRadius: scaleBorderRadius.correctBorderRadius,
+    borderBottomRightRadius: scaleBorderRadius.correctBorderRadius,
+    boxShadow: scaleBoxShadow.correctBoxShadow,
+};
+
+exports.scaleCorrectors = scaleCorrectors;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/styles/scale-correction.mjs

@@ -0,0 +1,21 @@
+import { correctBorderRadius } from './scale-border-radius.mjs';
+import { correctBoxShadow } from './scale-box-shadow.mjs';
+
+const scaleCorrectors = {
+    borderRadius: {
+        ...correctBorderRadius,
+        applyTo: [
+            "borderTopLeftRadius",
+            "borderTopRightRadius",
+            "borderBottomLeftRadius",
+            "borderBottomRightRadius",
+        ],
+    },
+    borderTopLeftRadius: correctBorderRadius,
+    borderTopRightRadius: correctBorderRadius,
+    borderBottomLeftRadius: correctBorderRadius,
+    borderBottomRightRadius: correctBorderRadius,
+    boxShadow: correctBoxShadow,
+};
+
+export { scaleCorrectors };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/styles/transform.js

@@ -0,0 +1,51 @@
+'use strict';
+
+function buildProjectionTransform(delta, treeScale, latestTransform) {
+    let transform = "";
+    /**
+     * The translations we use to calculate are always relative to the viewport coordinate space.
+     * But when we apply scales, we also scale the coordinate space of an element and its children.
+     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need
+     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.
+     */
+    const xTranslate = delta.x.translate / treeScale.x;
+    const yTranslate = delta.y.translate / treeScale.y;
+    const zTranslate = latestTransform?.z || 0;
+    if (xTranslate || yTranslate || zTranslate) {
+        transform = `translate3d(${xTranslate}px, ${yTranslate}px, ${zTranslate}px) `;
+    }
+    /**
+     * Apply scale correction for the tree transform.
+     * This will apply scale to the screen-orientated axes.
+     */
+    if (treeScale.x !== 1 || treeScale.y !== 1) {
+        transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;
+    }
+    if (latestTransform) {
+        const { transformPerspective, rotate, rotateX, rotateY, skewX, skewY } = latestTransform;
+        if (transformPerspective)
+            transform = `perspective(${transformPerspective}px) ${transform}`;
+        if (rotate)
+            transform += `rotate(${rotate}deg) `;
+        if (rotateX)
+            transform += `rotateX(${rotateX}deg) `;
+        if (rotateY)
+            transform += `rotateY(${rotateY}deg) `;
+        if (skewX)
+            transform += `skewX(${skewX}deg) `;
+        if (skewY)
+            transform += `skewY(${skewY}deg) `;
+    }
+    /**
+     * Apply scale to match the size of the element to the size we want it.
+     * This will apply scale to the element-orientated axes.
+     */
+    const elementScaleX = delta.x.scale * treeScale.x;
+    const elementScaleY = delta.y.scale * treeScale.y;
+    if (elementScaleX !== 1 || elementScaleY !== 1) {
+        transform += `scale(${elementScaleX}, ${elementScaleY})`;
+    }
+    return transform || "none";
+}
+
+exports.buildProjectionTransform = buildProjectionTransform;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/styles/transform.mjs

@@ -0,0 +1,49 @@
+function buildProjectionTransform(delta, treeScale, latestTransform) {
+    let transform = "";
+    /**
+     * The translations we use to calculate are always relative to the viewport coordinate space.
+     * But when we apply scales, we also scale the coordinate space of an element and its children.
+     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need
+     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.
+     */
+    const xTranslate = delta.x.translate / treeScale.x;
+    const yTranslate = delta.y.translate / treeScale.y;
+    const zTranslate = latestTransform?.z || 0;
+    if (xTranslate || yTranslate || zTranslate) {
+        transform = `translate3d(${xTranslate}px, ${yTranslate}px, ${zTranslate}px) `;
+    }
+    /**
+     * Apply scale correction for the tree transform.
+     * This will apply scale to the screen-orientated axes.
+     */
+    if (treeScale.x !== 1 || treeScale.y !== 1) {
+        transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;
+    }
+    if (latestTransform) {
+        const { transformPerspective, rotate, rotateX, rotateY, skewX, skewY } = latestTransform;
+        if (transformPerspective)
+            transform = `perspective(${transformPerspective}px) ${transform}`;
+        if (rotate)
+            transform += `rotate(${rotate}deg) `;
+        if (rotateX)
+            transform += `rotateX(${rotateX}deg) `;
+        if (rotateY)
+            transform += `rotateY(${rotateY}deg) `;
+        if (skewX)
+            transform += `skewX(${skewX}deg) `;
+        if (skewY)
+            transform += `skewY(${skewY}deg) `;
+    }
+    /**
+     * Apply scale to match the size of the element to the size we want it.
+     * This will apply scale to the element-orientated axes.
+     */
+    const elementScaleX = delta.x.scale * treeScale.x;
+    const elementScaleY = delta.y.scale * treeScale.y;
+    if (elementScaleX !== 1 || elementScaleY !== 1) {
+        transform += `scale(${elementScaleX}, ${elementScaleY})`;
+    }
+    return transform || "none";
+}
+
+export { buildProjectionTransform };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/utils/compare-by-depth.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const compareByDepth = (a, b) => a.depth - b.depth;
+
+exports.compareByDepth = compareByDepth;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/utils/compare-by-depth.mjs

@@ -0,0 +1,3 @@
+const compareByDepth = (a, b) => a.depth - b.depth;
+
+export { compareByDepth };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/utils/each-axis.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function eachAxis(callback) {
+    return [callback("x"), callback("y")];
+}
+
+exports.eachAxis = eachAxis;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/utils/each-axis.mjs

@@ -0,0 +1,5 @@
+function eachAxis(callback) {
+    return [callback("x"), callback("y")];
+}
+
+export { eachAxis };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/utils/flat-tree.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var compareByDepth = require('./compare-by-depth.js');
+var array = require('../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/array.js');
+
+class FlatTree {
+    constructor() {
+        this.children = [];
+        this.isDirty = false;
+    }
+    add(child) {
+        array.addUniqueItem(this.children, child);
+        this.isDirty = true;
+    }
+    remove(child) {
+        array.removeItem(this.children, child);
+        this.isDirty = true;
+    }
+    forEach(callback) {
+        this.isDirty && this.children.sort(compareByDepth.compareByDepth);
+        this.isDirty = false;
+        this.children.forEach(callback);
+    }
+}
+
+exports.FlatTree = FlatTree;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/utils/flat-tree.mjs

@@ -0,0 +1,24 @@
+import { compareByDepth } from './compare-by-depth.mjs';
+import { addUniqueItem, removeItem } from '../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/array.mjs';
+
+class FlatTree {
+    constructor() {
+        this.children = [];
+        this.isDirty = false;
+    }
+    add(child) {
+        addUniqueItem(this.children, child);
+        this.isDirty = true;
+    }
+    remove(child) {
+        removeItem(this.children, child);
+        this.isDirty = true;
+    }
+    forEach(callback) {
+        this.isDirty && this.children.sort(compareByDepth);
+        this.isDirty = false;
+        this.children.forEach(callback);
+    }
+}
+
+export { FlatTree };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/utils/has-transform.js

@@ -0,0 +1,30 @@
+'use strict';
+
+function isIdentityScale(scale) {
+    return scale === undefined || scale === 1;
+}
+function hasScale({ scale, scaleX, scaleY }) {
+    return (!isIdentityScale(scale) ||
+        !isIdentityScale(scaleX) ||
+        !isIdentityScale(scaleY));
+}
+function hasTransform(values) {
+    return (hasScale(values) ||
+        has2DTranslate(values) ||
+        values.z ||
+        values.rotate ||
+        values.rotateX ||
+        values.rotateY ||
+        values.skewX ||
+        values.skewY);
+}
+function has2DTranslate(values) {
+    return is2DTranslate(values.x) || is2DTranslate(values.y);
+}
+function is2DTranslate(value) {
+    return value && value !== "0%";
+}
+
+exports.has2DTranslate = has2DTranslate;
+exports.hasScale = hasScale;
+exports.hasTransform = hasTransform;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/projection/utils/has-transform.mjs

@@ -0,0 +1,26 @@
+function isIdentityScale(scale) {
+    return scale === undefined || scale === 1;
+}
+function hasScale({ scale, scaleX, scaleY }) {
+    return (!isIdentityScale(scale) ||
+        !isIdentityScale(scaleX) ||
+        !isIdentityScale(scaleY));
+}
+function hasTransform(values) {
+    return (hasScale(values) ||
+        has2DTranslate(values) ||
+        values.z ||
+        values.rotate ||
+        values.rotateX ||
+        values.rotateY ||
+        values.skewX ||
+        values.skewY);
+}
+function has2DTranslate(values) {
+    return is2DTranslate(values.x) || is2DTranslate(values.y);
+}
+function is2DTranslate(value) {
+    return value && value !== "0%";
+}
+
+export { has2DTranslate, hasScale, hasTransform };