@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/value/types/color/utils.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var floatRegex = require('../utils/float-regex.js');
+var isNullish = require('../utils/is-nullish.js');
+var singleColorRegex = require('../utils/single-color-regex.js');
+
+/**
+ * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,
+ * but false if a number or multiple colors
+ */
+const isColorString = (type, testProp) => (v) => {
+    return Boolean((typeof v === "string" &&
+        singleColorRegex.singleColorRegex.test(v) &&
+        v.startsWith(type)) ||
+        (testProp &&
+            !isNullish.isNullish(v) &&
+            Object.prototype.hasOwnProperty.call(v, testProp)));
+};
+const splitColor = (aName, bName, cName) => (v) => {
+    if (typeof v !== "string")
+        return v;
+    const [a, b, c, alpha] = v.match(floatRegex.floatRegex);
+    return {
+        [aName]: parseFloat(a),
+        [bName]: parseFloat(b),
+        [cName]: parseFloat(c),
+        alpha: alpha !== undefined ? parseFloat(alpha) : 1,
+    };
+};
+
+exports.isColorString = isColorString;
+exports.splitColor = splitColor;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/color/utils.mjs

@@ -0,0 +1,29 @@
+import { floatRegex } from '../utils/float-regex.mjs';
+import { isNullish } from '../utils/is-nullish.mjs';
+import { singleColorRegex } from '../utils/single-color-regex.mjs';
+
+/**
+ * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,
+ * but false if a number or multiple colors
+ */
+const isColorString = (type, testProp) => (v) => {
+    return Boolean((typeof v === "string" &&
+        singleColorRegex.test(v) &&
+        v.startsWith(type)) ||
+        (testProp &&
+            !isNullish(v) &&
+            Object.prototype.hasOwnProperty.call(v, testProp)));
+};
+const splitColor = (aName, bName, cName) => (v) => {
+    if (typeof v !== "string")
+        return v;
+    const [a, b, c, alpha] = v.match(floatRegex);
+    return {
+        [aName]: parseFloat(a),
+        [bName]: parseFloat(b),
+        [cName]: parseFloat(c),
+        alpha: alpha !== undefined ? parseFloat(alpha) : 1,
+    };
+};
+
+export { isColorString, splitColor };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/complex/filter.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var index = require('./index.js');
+var floatRegex = require('../utils/float-regex.js');
+
+/**
+ * Properties that should default to 1 or 100%
+ */
+const maxDefaults = new Set(["brightness", "contrast", "saturate", "opacity"]);
+function applyDefaultFilter(v) {
+    const [name, value] = v.slice(0, -1).split("(");
+    if (name === "drop-shadow")
+        return v;
+    const [number] = value.match(floatRegex.floatRegex) || [];
+    if (!number)
+        return v;
+    const unit = value.replace(number, "");
+    let defaultValue = maxDefaults.has(name) ? 1 : 0;
+    if (number !== value)
+        defaultValue *= 100;
+    return name + "(" + defaultValue + unit + ")";
+}
+const functionRegex = /\b([a-z-]*)\(.*?\)/gu;
+const filter = {
+    ...index.complex,
+    getAnimatableNone: (v) => {
+        const functions = v.match(functionRegex);
+        return functions ? functions.map(applyDefaultFilter).join(" ") : v;
+    },
+};
+
+exports.filter = filter;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/complex/filter.mjs

@@ -0,0 +1,30 @@
+import { complex } from './index.mjs';
+import { floatRegex } from '../utils/float-regex.mjs';
+
+/**
+ * Properties that should default to 1 or 100%
+ */
+const maxDefaults = new Set(["brightness", "contrast", "saturate", "opacity"]);
+function applyDefaultFilter(v) {
+    const [name, value] = v.slice(0, -1).split("(");
+    if (name === "drop-shadow")
+        return v;
+    const [number] = value.match(floatRegex) || [];
+    if (!number)
+        return v;
+    const unit = value.replace(number, "");
+    let defaultValue = maxDefaults.has(name) ? 1 : 0;
+    if (number !== value)
+        defaultValue *= 100;
+    return name + "(" + defaultValue + unit + ")";
+}
+const functionRegex = /\b([a-z-]*)\(.*?\)/gu;
+const filter = {
+    ...complex,
+    getAnimatableNone: (v) => {
+        const functions = v.match(functionRegex);
+        return functions ? functions.map(applyDefaultFilter).join(" ") : v;
+    },
+};
+
+export { filter };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/complex/index.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var index = require('../color/index.js');
+var colorRegex = require('../utils/color-regex.js');
+var floatRegex = require('../utils/float-regex.js');
+var sanitize = require('../utils/sanitize.js');
+
+function test(v) {
+    return (isNaN(v) &&
+        typeof v === "string" &&
+        (v.match(floatRegex.floatRegex)?.length || 0) +
+            (v.match(colorRegex.colorRegex)?.length || 0) >
+            0);
+}
+const NUMBER_TOKEN = "number";
+const COLOR_TOKEN = "color";
+const VAR_TOKEN = "var";
+const VAR_FUNCTION_TOKEN = "var(";
+const SPLIT_TOKEN = "${}";
+// this regex consists of the `singleCssVariableRegex|rgbHSLValueRegex|digitRegex`
+const complexRegex = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function analyseComplexValue(value) {
+    const originalValue = value.toString();
+    const values = [];
+    const indexes = {
+        color: [],
+        number: [],
+        var: [],
+    };
+    const types = [];
+    let i = 0;
+    const tokenised = originalValue.replace(complexRegex, (parsedValue) => {
+        if (index.color.test(parsedValue)) {
+            indexes.color.push(i);
+            types.push(COLOR_TOKEN);
+            values.push(index.color.parse(parsedValue));
+        }
+        else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {
+            indexes.var.push(i);
+            types.push(VAR_TOKEN);
+            values.push(parsedValue);
+        }
+        else {
+            indexes.number.push(i);
+            types.push(NUMBER_TOKEN);
+            values.push(parseFloat(parsedValue));
+        }
+        ++i;
+        return SPLIT_TOKEN;
+    });
+    const split = tokenised.split(SPLIT_TOKEN);
+    return { values, split, indexes, types };
+}
+function parseComplexValue(v) {
+    return analyseComplexValue(v).values;
+}
+function buildTransformer({ split, types }) {
+    const numSections = split.length;
+    return (v) => {
+        let output = "";
+        for (let i = 0; i < numSections; i++) {
+            output += split[i];
+            if (v[i] !== undefined) {
+                const type = types[i];
+                if (type === NUMBER_TOKEN) {
+                    output += sanitize.sanitize(v[i]);
+                }
+                else if (type === COLOR_TOKEN) {
+                    output += index.color.transform(v[i]);
+                }
+                else {
+                    output += v[i];
+                }
+            }
+        }
+        return output;
+    };
+}
+function createTransformer(source) {
+    return buildTransformer(analyseComplexValue(source));
+}
+const convertNumbersToZero = (v) => typeof v === "number" ? 0 : index.color.test(v) ? index.color.getAnimatableNone(v) : v;
+/**
+ * Convert a parsed value to its zero equivalent, but preserve numbers
+ * that act as divisors in CSS calc() expressions.
+ *
+ * analyseComplexValue extracts numbers from CSS strings and puts the
+ * surrounding text into a `split` template array. For example:
+ *   "calc(var(--gap) / 5)"  →  values: [var(--gap), 5]
+ *                               split:  ["calc(", " / ", ")"]
+ *
+ * When building a zero-equivalent for animation, naively zeroing all
+ * numbers turns the divisor into 0 → "calc(var(--gap) / 0)" → NaN.
+ * We detect this by checking whether the text preceding a number
+ * (split[i]) ends with "/" — the CSS calc division operator.
+ */
+const convertToZero = (value, splitBefore) => {
+    if (typeof value === "number") {
+        return splitBefore?.trim().endsWith("/") ? value : 0;
+    }
+    return convertNumbersToZero(value);
+};
+function getAnimatableNone(v) {
+    const info = analyseComplexValue(v);
+    const transformer = buildTransformer(info);
+    return transformer(info.values.map((value, i) => convertToZero(value, info.split[i])));
+}
+const complex = {
+    test,
+    parse: parseComplexValue,
+    createTransformer,
+    getAnimatableNone,
+};
+
+exports.analyseComplexValue = analyseComplexValue;
+exports.complex = complex;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/complex/index.mjs

@@ -0,0 +1,113 @@
+import { color } from '../color/index.mjs';
+import { colorRegex } from '../utils/color-regex.mjs';
+import { floatRegex } from '../utils/float-regex.mjs';
+import { sanitize } from '../utils/sanitize.mjs';
+
+function test(v) {
+    return (isNaN(v) &&
+        typeof v === "string" &&
+        (v.match(floatRegex)?.length || 0) +
+            (v.match(colorRegex)?.length || 0) >
+            0);
+}
+const NUMBER_TOKEN = "number";
+const COLOR_TOKEN = "color";
+const VAR_TOKEN = "var";
+const VAR_FUNCTION_TOKEN = "var(";
+const SPLIT_TOKEN = "${}";
+// this regex consists of the `singleCssVariableRegex|rgbHSLValueRegex|digitRegex`
+const complexRegex = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function analyseComplexValue(value) {
+    const originalValue = value.toString();
+    const values = [];
+    const indexes = {
+        color: [],
+        number: [],
+        var: [],
+    };
+    const types = [];
+    let i = 0;
+    const tokenised = originalValue.replace(complexRegex, (parsedValue) => {
+        if (color.test(parsedValue)) {
+            indexes.color.push(i);
+            types.push(COLOR_TOKEN);
+            values.push(color.parse(parsedValue));
+        }
+        else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {
+            indexes.var.push(i);
+            types.push(VAR_TOKEN);
+            values.push(parsedValue);
+        }
+        else {
+            indexes.number.push(i);
+            types.push(NUMBER_TOKEN);
+            values.push(parseFloat(parsedValue));
+        }
+        ++i;
+        return SPLIT_TOKEN;
+    });
+    const split = tokenised.split(SPLIT_TOKEN);
+    return { values, split, indexes, types };
+}
+function parseComplexValue(v) {
+    return analyseComplexValue(v).values;
+}
+function buildTransformer({ split, types }) {
+    const numSections = split.length;
+    return (v) => {
+        let output = "";
+        for (let i = 0; i < numSections; i++) {
+            output += split[i];
+            if (v[i] !== undefined) {
+                const type = types[i];
+                if (type === NUMBER_TOKEN) {
+                    output += sanitize(v[i]);
+                }
+                else if (type === COLOR_TOKEN) {
+                    output += color.transform(v[i]);
+                }
+                else {
+                    output += v[i];
+                }
+            }
+        }
+        return output;
+    };
+}
+function createTransformer(source) {
+    return buildTransformer(analyseComplexValue(source));
+}
+const convertNumbersToZero = (v) => typeof v === "number" ? 0 : color.test(v) ? color.getAnimatableNone(v) : v;
+/**
+ * Convert a parsed value to its zero equivalent, but preserve numbers
+ * that act as divisors in CSS calc() expressions.
+ *
+ * analyseComplexValue extracts numbers from CSS strings and puts the
+ * surrounding text into a `split` template array. For example:
+ *   "calc(var(--gap) / 5)"  →  values: [var(--gap), 5]
+ *                               split:  ["calc(", " / ", ")"]
+ *
+ * When building a zero-equivalent for animation, naively zeroing all
+ * numbers turns the divisor into 0 → "calc(var(--gap) / 0)" → NaN.
+ * We detect this by checking whether the text preceding a number
+ * (split[i]) ends with "/" — the CSS calc division operator.
+ */
+const convertToZero = (value, splitBefore) => {
+    if (typeof value === "number") {
+        return splitBefore?.trim().endsWith("/") ? value : 0;
+    }
+    return convertNumbersToZero(value);
+};
+function getAnimatableNone(v) {
+    const info = analyseComplexValue(v);
+    const transformer = buildTransformer(info);
+    return transformer(info.values.map((value, i) => convertToZero(value, info.split[i])));
+}
+const complex = {
+    test,
+    parse: parseComplexValue,
+    createTransformer,
+    getAnimatableNone,
+};
+
+export { analyseComplexValue, complex };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/complex/mask.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var index = require('./index.js');
+
+const mask = {
+    ...index.complex,
+    getAnimatableNone: (v) => {
+        const parsed = index.complex.parse(v);
+        const transformer = index.complex.createTransformer(v);
+        return transformer(parsed.map((v) => typeof v === "number" ? 0 : typeof v === "object" ? { ...v, alpha: 1 } : v));
+    },
+};
+
+exports.mask = mask;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/complex/mask.mjs

@@ -0,0 +1,12 @@
+import { complex } from './index.mjs';
+
+const mask = {
+    ...complex,
+    getAnimatableNone: (v) => {
+        const parsed = complex.parse(v);
+        const transformer = complex.createTransformer(v);
+        return transformer(parsed.map((v) => typeof v === "number" ? 0 : typeof v === "object" ? { ...v, alpha: 1 } : v));
+    },
+};
+
+export { mask };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/dimensions.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var auto = require('./auto.js');
+var index = require('./numbers/index.js');
+var units = require('./numbers/units.js');
+var test = require('./test.js');
+
+/**
+ * A list of value types commonly used for dimensions
+ */
+const dimensionValueTypes = [index.number, units.px, units.percent, units.degrees, units.vw, units.vh, auto.auto];
+/**
+ * Tests a dimensional value against the list of dimension ValueTypes
+ */
+const findDimensionValueType = (v) => dimensionValueTypes.find(test.testValueType(v));
+
+exports.dimensionValueTypes = dimensionValueTypes;
+exports.findDimensionValueType = findDimensionValueType;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/dimensions.mjs

@@ -0,0 +1,15 @@
+import { auto } from './auto.mjs';
+import { number } from './numbers/index.mjs';
+import { px, percent, degrees, vw, vh } from './numbers/units.mjs';
+import { testValueType } from './test.mjs';
+
+/**
+ * A list of value types commonly used for dimensions
+ */
+const dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];
+/**
+ * Tests a dimensional value against the list of dimension ValueTypes
+ */
+const findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));
+
+export { dimensionValueTypes, findDimensionValueType };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/int.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var index = require('./numbers/index.js');
+
+const int = {
+    ...index.number,
+    transform: Math.round,
+};
+
+exports.int = int;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/int.mjs

@@ -0,0 +1,8 @@
+import { number } from './numbers/index.mjs';
+
+const int = {
+    ...number,
+    transform: Math.round,
+};
+
+export { int };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/maps/defaults.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var index = require('../color/index.js');
+var filter = require('../complex/filter.js');
+var mask = require('../complex/mask.js');
+var number = require('./number.js');
+
+/**
+ * A map of default value types for common values
+ */
+const defaultValueTypes = {
+    ...number.numberValueTypes,
+    // Color props
+    color: index.color,
+    backgroundColor: index.color,
+    outlineColor: index.color,
+    fill: index.color,
+    stroke: index.color,
+    // Border props
+    borderColor: index.color,
+    borderTopColor: index.color,
+    borderRightColor: index.color,
+    borderBottomColor: index.color,
+    borderLeftColor: index.color,
+    filter: filter.filter,
+    WebkitFilter: filter.filter,
+    mask: mask.mask,
+    WebkitMask: mask.mask,
+};
+/**
+ * Gets the default ValueType for the provided value key
+ */
+const getDefaultValueType = (key) => defaultValueTypes[key];
+
+exports.defaultValueTypes = defaultValueTypes;
+exports.getDefaultValueType = getDefaultValueType;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/maps/defaults.mjs

@@ -0,0 +1,33 @@
+import { color } from '../color/index.mjs';
+import { filter } from '../complex/filter.mjs';
+import { mask } from '../complex/mask.mjs';
+import { numberValueTypes } from './number.mjs';
+
+/**
+ * A map of default value types for common values
+ */
+const defaultValueTypes = {
+    ...numberValueTypes,
+    // Color props
+    color,
+    backgroundColor: color,
+    outlineColor: color,
+    fill: color,
+    stroke: color,
+    // Border props
+    borderColor: color,
+    borderTopColor: color,
+    borderRightColor: color,
+    borderBottomColor: color,
+    borderLeftColor: color,
+    filter,
+    WebkitFilter: filter,
+    mask,
+    WebkitMask: mask,
+};
+/**
+ * Gets the default ValueType for the provided value key
+ */
+const getDefaultValueType = (key) => defaultValueTypes[key];
+
+export { defaultValueTypes, getDefaultValueType };

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/maps/number.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var int = require('../int.js');
+var index = require('../numbers/index.js');
+var units = require('../numbers/units.js');
+var transform = require('./transform.js');
+
+const numberValueTypes = {
+    // Border props
+    borderWidth: units.px,
+    borderTopWidth: units.px,
+    borderRightWidth: units.px,
+    borderBottomWidth: units.px,
+    borderLeftWidth: units.px,
+    borderRadius: units.px,
+    borderTopLeftRadius: units.px,
+    borderTopRightRadius: units.px,
+    borderBottomRightRadius: units.px,
+    borderBottomLeftRadius: units.px,
+    // Positioning props
+    width: units.px,
+    maxWidth: units.px,
+    height: units.px,
+    maxHeight: units.px,
+    top: units.px,
+    right: units.px,
+    bottom: units.px,
+    left: units.px,
+    inset: units.px,
+    insetBlock: units.px,
+    insetBlockStart: units.px,
+    insetBlockEnd: units.px,
+    insetInline: units.px,
+    insetInlineStart: units.px,
+    insetInlineEnd: units.px,
+    // Spacing props
+    padding: units.px,
+    paddingTop: units.px,
+    paddingRight: units.px,
+    paddingBottom: units.px,
+    paddingLeft: units.px,
+    paddingBlock: units.px,
+    paddingBlockStart: units.px,
+    paddingBlockEnd: units.px,
+    paddingInline: units.px,
+    paddingInlineStart: units.px,
+    paddingInlineEnd: units.px,
+    margin: units.px,
+    marginTop: units.px,
+    marginRight: units.px,
+    marginBottom: units.px,
+    marginLeft: units.px,
+    marginBlock: units.px,
+    marginBlockStart: units.px,
+    marginBlockEnd: units.px,
+    marginInline: units.px,
+    marginInlineStart: units.px,
+    marginInlineEnd: units.px,
+    // Typography
+    fontSize: units.px,
+    // Misc
+    backgroundPositionX: units.px,
+    backgroundPositionY: units.px,
+    ...transform.transformValueTypes,
+    zIndex: int.int,
+    // SVG
+    fillOpacity: index.alpha,
+    strokeOpacity: index.alpha,
+    numOctaves: int.int,
+};
+
+exports.numberValueTypes = numberValueTypes;

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/value/types/maps/number.mjs

@@ -0,0 +1,70 @@
+import { int } from '../int.mjs';
+import { alpha } from '../numbers/index.mjs';
+import { px } from '../numbers/units.mjs';
+import { transformValueTypes } from './transform.mjs';
+
+const numberValueTypes = {
+    // Border props
+    borderWidth: px,
+    borderTopWidth: px,
+    borderRightWidth: px,
+    borderBottomWidth: px,
+    borderLeftWidth: px,
+    borderRadius: px,
+    borderTopLeftRadius: px,
+    borderTopRightRadius: px,
+    borderBottomRightRadius: px,
+    borderBottomLeftRadius: px,
+    // Positioning props
+    width: px,
+    maxWidth: px,
+    height: px,
+    maxHeight: px,
+    top: px,
+    right: px,
+    bottom: px,
+    left: px,
+    inset: px,
+    insetBlock: px,
+    insetBlockStart: px,
+    insetBlockEnd: px,
+    insetInline: px,
+    insetInlineStart: px,
+    insetInlineEnd: px,
+    // Spacing props
+    padding: px,
+    paddingTop: px,
+    paddingRight: px,
+    paddingBottom: px,
+    paddingLeft: px,
+    paddingBlock: px,
+    paddingBlockStart: px,
+    paddingBlockEnd: px,
+    paddingInline: px,
+    paddingInlineStart: px,
+    paddingInlineEnd: px,
+    margin: px,
+    marginTop: px,
+    marginRight: px,
+    marginBottom: px,
+    marginLeft: px,
+    marginBlock: px,
+    marginBlockStart: px,
+    marginBlockEnd: px,
+    marginInline: px,
+    marginInlineStart: px,
+    marginInlineEnd: px,
+    // Typography
+    fontSize: px,
+    // Misc
+    backgroundPositionX: px,
+    backgroundPositionY: px,
+    ...transformValueTypes,
+    zIndex: int,
+    // SVG
+    fillOpacity: alpha,
+    strokeOpacity: alpha,
+    numOctaves: int,
+};
+
+export { numberValueTypes };