zhiaiwan-utils 1.0.3

package/dist/cjs/_internal/baseUpdate.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = baseUpdate;
+const basePath_1 = require("./basePath");
+const toPath_1 = __importDefault(require("./toPath"));
+const isIndex_1 = __importDefault(require("./isIndex"));
+function assignValue(container, key, value) {
+    if (Array.isArray(container) && (0, isIndex_1.default)(key)) {
+        const index = Number(key);
+        container[index] = value;
+        if (index >= container.length) {
+            container.length = index + 1;
+        }
+        return;
+    }
+    container[key] = value;
+}
+function getNestedValue(container, key) {
+    return container[key];
+}
+function createNestedValue(nextKey, customizer, parent, key) {
+    if (customizer && parent && key !== undefined) {
+        const customized = customizer(getNestedValue(parent, key), key, parent);
+        if (customized !== undefined) {
+            return customized;
+        }
+    }
+    return (0, isIndex_1.default)(nextKey) ? [] : {};
+}
+function setPathValueWithCustomizer(object, path, value, customizer) {
+    if (path.length === 0) {
+        return;
+    }
+    let current = object;
+    for (let index = 0; index < path.length - 1; index++) {
+        const key = path[index];
+        const nextKey = path[index + 1];
+        let next = getNestedValue(current, key);
+        if (next == null || typeof next !== 'object') {
+            next = createNestedValue(nextKey, customizer, current, key);
+            assignValue(current, key, next);
+        }
+        current = next;
+    }
+    assignValue(current, path[path.length - 1], value);
+}
+/**
+ * update / updateWith 共享内核。
+ *
+ * @internal
+ */
+function baseUpdate(object, path, updater, customizer) {
+    const keys = (0, toPath_1.default)(path);
+    const current = (0, basePath_1.getPathValue)(object, keys);
+    const nextValue = updater(current);
+    if (customizer) {
+        setPathValueWithCustomizer(object, keys, nextValue, customizer);
+        return object;
+    }
+    (0, basePath_1.setPathValue)(object, keys, nextValue);
+    return object;
+}

package/dist/cjs/_internal/coerceToString.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = coerceToString;
+/**
+ * 内部辅助：将值转为字符串，语义对齐 convert/toString。
+ *
+ * @internal
+ */
+function coerceToString(value) {
+    if (value == null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'symbol') {
+        return Symbol.prototype.toString.call(value);
+    }
+    const result = String(value);
+    return result === '0' && 1 / value === -Infinity ? '-0' : result;
+}

package/dist/cjs/_internal/colorMath.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEX_COLOR_RE = void 0;
+exports.expandHexShorthand = expandHexShorthand;
+exports.parseHexColor = parseHexColor;
+exports.clampRgbComponent = clampRgbComponent;
+exports.formatRgbString = formatRgbString;
+exports.rgbComponentsToHex = rgbComponentsToHex;
+exports.tintHexColor = tintHexColor;
+exports.mixHexColorsToRgb = mixHexColorsToRgb;
+exports.HEX_COLOR_RE = /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+function isHexColor(color) {
+    return exports.HEX_COLOR_RE.test(color.trim());
+}
+function expandHexShorthand(hex) {
+    const withHash = hex.startsWith('#') ? hex : `#${hex}`;
+    if (withHash.length === 4) {
+        return `#${withHash[1]}${withHash[1]}${withHash[2]}${withHash[2]}${withHash[3]}${withHash[3]}`;
+    }
+    return withHash;
+}
+function parseHexColor(hex) {
+    const trimmed = hex.trim();
+    const withHash = trimmed.startsWith('#') ? trimmed : `#${trimmed}`;
+    if (!isHexColor(withHash)) {
+        return null;
+    }
+    const expanded = expandHexShorthand(withHash);
+    return {
+        r: parseInt(expanded.slice(1, 3), 16),
+        g: parseInt(expanded.slice(3, 5), 16),
+        b: parseInt(expanded.slice(5, 7), 16),
+    };
+}
+function clampRgbComponent(value) {
+    return Math.max(0, Math.min(255, Math.round(value)));
+}
+function formatRgbString(r, g, b) {
+    return `rgb(${clampRgbComponent(r)}, ${clampRgbComponent(g)}, ${clampRgbComponent(b)})`;
+}
+function rgbComponentsToHex(r, g, b) {
+    const red = clampRgbComponent(r).toString(16).padStart(2, '0');
+    const green = clampRgbComponent(g).toString(16).padStart(2, '0');
+    const blue = clampRgbComponent(b).toString(16).padStart(2, '0');
+    return `#${red}${green}${blue}`.toUpperCase();
+}
+/** Element Plus 主题色向白色混合 */
+function tintHexColor(hex, tint) {
+    const rgb = parseHexColor(hex);
+    if (!rgb) {
+        return null;
+    }
+    const mixChannel = (channel) => clampRgbComponent(channel + Math.round(tint * (255 - channel)));
+    return rgbComponentsToHex(mixChannel(rgb.r), mixChannel(rgb.g), mixChannel(rgb.b));
+}
+/** 两色按百分比混合，返回 rgb(r, g, b) 字符串 */
+function mixHexColorsToRgb(primary, target, amountPercent) {
+    const from = parseHexColor(primary);
+    const to = parseHexColor(target);
+    if (!from || !to) {
+        return null;
+    }
+    const ratio = amountPercent / 100;
+    const mixChannel = (a, b) => clampRgbComponent((b - a) * ratio + a);
+    return formatRgbString(mixChannel(from.r, to.r), mixChannel(from.g, to.g), mixChannel(from.b, to.b));
+}

package/dist/cjs/_internal/compareValues.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareAsc = compareAsc;
+exports.compareDesc = compareDesc;
+/**
+ * 升序比较两个值，语义对齐 Lodash compareAscending。
+ *
+ * @internal
+ */
+function compareAsc(value, other) {
+    if (value === other) {
+        return 0;
+    }
+    const valueIsNaN = typeof value === 'number' && Number.isNaN(value);
+    const otherIsNaN = typeof other === 'number' && Number.isNaN(other);
+    if (valueIsNaN && otherIsNaN) {
+        return 0;
+    }
+    if (value == null) {
+        return -1;
+    }
+    if (other == null) {
+        return 1;
+    }
+    if (valueIsNaN) {
+        return 1;
+    }
+    if (otherIsNaN) {
+        return -1;
+    }
+    if (typeof value === 'string' && typeof other === 'string') {
+        return value.localeCompare(other);
+    }
+    if (value < other) {
+        return -1;
+    }
+    if (value > other) {
+        return 1;
+    }
+    return String(value).localeCompare(String(other));
+}
+/**
+ * 降序比较两个值，语义对齐 Lodash compareDescending。
+ *
+ * @internal
+ */
+function compareDesc(value, other) {
+    return compareAsc(other, value);
+}

package/dist/cjs/_internal/composePartials.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partialPlaceholder = void 0;
+exports.mergePartialArgs = mergePartialArgs;
+/** partial / partialRight 占位符，行为对齐 Lodash placeholder。 */
+exports.partialPlaceholder = Symbol('zhiaiwanUtils.partial.placeholder');
+function composeArgs(args, partials) {
+    const result = [];
+    let argsIndex = 0;
+    for (const partial of partials) {
+        if (partial === exports.partialPlaceholder) {
+            result.push(args[argsIndex++]);
+            continue;
+        }
+        result.push(partial);
+    }
+    while (argsIndex < args.length) {
+        result.push(args[argsIndex++]);
+    }
+    return result;
+}
+function composeArgsRight(args, partials) {
+    const result = [...partials];
+    let argsIndex = args.length - 1;
+    for (let index = result.length - 1; index >= 0; index--) {
+        if (result[index] === exports.partialPlaceholder) {
+            result[index] = args[argsIndex--];
+        }
+    }
+    return [...args.slice(0, argsIndex + 1), ...result];
+}
+/**
+ * 内部辅助：合并 partial 预置参数与调用参数。
+ *
+ * @internal
+ */
+function mergePartialArgs(args, partials, side) {
+    return side === 'left' ? composeArgs(args, partials) : composeArgsRight(args, partials);
+}

package/dist/cjs/_internal/createCompounder.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createCompounder;
+const deburr_1 = __importDefault(require("./deburr"));
+const words_1 = __importDefault(require("./words"));
+const APOSTROPHE_PATTERN = /['\u2019]/g;
+/**
+ * 生成 kebabCase / snakeCase 等复合命名转换器，对齐 Lodash createCompounder。
+ *
+ * @internal
+ */
+function createCompounder(combiner) {
+    return function compounder(string) {
+        const input = String(string !== null && string !== void 0 ? string : '');
+        if (!input) {
+            return '';
+        }
+        const tokens = (0, words_1.default)((0, deburr_1.default)(input).replace(APOSTROPHE_PATTERN, ''));
+        return tokens.reduce(combiner, '');
+    };
+}

package/dist/cjs/_internal/deburr.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = deburr;
+const LATIN = /[\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u00ff\u0100-\u017f]/g;
+const COMBO_MARK = /[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]/g;
+const DEBURRED_LETTERS = {
+    '\u00c0': 'A', '\u00c1': 'A', '\u00c2': 'A', '\u00c3': 'A', '\u00c4': 'A', '\u00c5': 'A',
+    '\u00e0': 'a', '\u00e1': 'a', '\u00e2': 'a', '\u00e3': 'a', '\u00e4': 'a', '\u00e5': 'a',
+    '\u00c7': 'C', '\u00e7': 'c',
+    '\u00d0': 'D', '\u00f0': 'd',
+    '\u00c8': 'E', '\u00c9': 'E', '\u00ca': 'E', '\u00cb': 'E',
+    '\u00e8': 'e', '\u00e9': 'e', '\u00ea': 'e', '\u00eb': 'e',
+    '\u00cc': 'I', '\u00cd': 'I', '\u00ce': 'I', '\u00cf': 'I',
+    '\u00ec': 'i', '\u00ed': 'i', '\u00ee': 'i', '\u00ef': 'i',
+    '\u00d1': 'N', '\u00f1': 'n',
+    '\u00d2': 'O', '\u00d3': 'O', '\u00d4': 'O', '\u00d5': 'O', '\u00d6': 'O', '\u00d8': 'O',
+    '\u00f2': 'o', '\u00f3': 'o', '\u00f4': 'o', '\u00f5': 'o', '\u00f6': 'o', '\u00f8': 'o',
+    '\u00d9': 'U', '\u00da': 'U', '\u00db': 'U', '\u00dc': 'U',
+    '\u00f9': 'u', '\u00fa': 'u', '\u00fb': 'u', '\u00fc': 'u',
+    '\u00dd': 'Y', '\u00fd': 'y', '\u00ff': 'y',
+    '\u00c6': 'Ae', '\u00e6': 'ae',
+    '\u00de': 'Th', '\u00fe': 'th',
+    '\u00df': 'ss',
+    '\u0100': 'A', '\u0102': 'A', '\u0104': 'A',
+    '\u0101': 'a', '\u0103': 'a', '\u0105': 'a',
+    '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
+    '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
+    '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
+    '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
+    '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
+    '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
+    '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
+    '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
+    '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
+    '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
+    '\u0134': 'J', '\u0135': 'j',
+    '\u0136': 'K', '\u0137': 'k', '\u0138': 'k',
+    '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
+    '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
+    '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
+    '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
+    '\u014c': 'O', '\u014e': 'O', '\u0150': 'O',
+    '\u014d': 'o', '\u014f': 'o', '\u0151': 'o',
+    '\u0154': 'R', '\u0156': 'R', '\u0158': 'R',
+    '\u0155': 'r', '\u0157': 'r', '\u0159': 'r',
+    '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
+    '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's',
+    '\u0162': 'T', '\u0164': 'T', '\u0166': 'T',
+    '\u0163': 't', '\u0165': 't', '\u0167': 't',
+    '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
+    '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
+    '\u0174': 'W', '\u0175': 'w',
+    '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y',
+    '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z',
+    '\u017a': 'z', '\u017c': 'z', '\u017e': 'z',
+    '\u0132': 'IJ', '\u0133': 'ij',
+    '\u0152': 'Oe', '\u0153': 'oe',
+    '\u0149': "'n", '\u017f': 's',
+};
+function deburrLetter(letter) {
+    var _a;
+    return (_a = DEBURRED_LETTERS[letter]) !== null && _a !== void 0 ? _a : letter;
+}
+/**
+ * 将拉丁扩展字符映射为基本拉丁字母并移除组合变音符号，对齐 Lodash deburr。
+ *
+ * @internal
+ */
+function deburr(string) {
+    if (!string) {
+        return string;
+    }
+    return string.replace(LATIN, deburrLetter).replace(COMBO_MARK, '');
+}

package/dist/cjs/_internal/flattenPaths.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flattenPaths;
+/**
+ * 内部辅助：展平 pick / omit 的路径参数。
+ *
+ * @internal
+ */
+function flattenPaths(paths) {
+    const result = [];
+    for (const path of paths) {
+        if (Array.isArray(path)) {
+            for (const item of path) {
+                result.push(String(item));
+            }
+            continue;
+        }
+        result.push(String(path));
+    }
+    return result;
+}

package/dist/cjs/_internal/htmlEscape.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeHtml = escapeHtml;
+exports.unescapeHtml = unescapeHtml;
+const HTML_ESCAPES = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+const HTML_UNESCAPES = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&#39;': "'",
+};
+const RE_UNESCAPED_HTML = /[&<>"']/g;
+const RE_ESCAPED_HTML = /&(?:amp|lt|gt|quot|#39);/g;
+/**
+ * 内部辅助：转义 HTML 特殊字符。
+ *
+ * @internal
+ */
+function escapeHtml(string) {
+    return string.replace(RE_UNESCAPED_HTML, (char) => HTML_ESCAPES[char]);
+}
+/**
+ * 内部辅助：反转义 HTML 实体。
+ *
+ * @internal
+ */
+function unescapeHtml(string) {
+    return string.replace(RE_ESCAPED_HTML, (entity) => HTML_UNESCAPES[entity]);
+}

package/dist/cjs/_internal/identity.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = identity;
+/**
+ * 返回第一个参数，Lodash `identity` 语义。
+ *
+ * @internal
+ */
+function identity(value) {
+    return value;
+}

package/dist/cjs/_internal/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPath = exports.baseIsMatch = exports.baseIsEqual = exports.baseClone = exports.isArguments = exports.isIndex = exports.isPlainObject = void 0;
+// 内部共享逻辑聚合。此目录不对外 export，也不在 package.json exports 中暴露。
+var isPlainObject_1 = require("./isPlainObject");
+Object.defineProperty(exports, "isPlainObject", { enumerable: true, get: function () { return __importDefault(isPlainObject_1).default; } });
+var isIndex_1 = require("./isIndex");
+Object.defineProperty(exports, "isIndex", { enumerable: true, get: function () { return __importDefault(isIndex_1).default; } });
+var isArguments_1 = require("./isArguments");
+Object.defineProperty(exports, "isArguments", { enumerable: true, get: function () { return __importDefault(isArguments_1).default; } });
+var baseClone_1 = require("./baseClone");
+Object.defineProperty(exports, "baseClone", { enumerable: true, get: function () { return __importDefault(baseClone_1).default; } });
+var baseIsEqual_1 = require("./baseIsEqual");
+Object.defineProperty(exports, "baseIsEqual", { enumerable: true, get: function () { return __importDefault(baseIsEqual_1).default; } });
+var baseIsMatch_1 = require("./baseIsMatch");
+Object.defineProperty(exports, "baseIsMatch", { enumerable: true, get: function () { return __importDefault(baseIsMatch_1).default; } });
+var toPath_1 = require("./toPath");
+Object.defineProperty(exports, "toPath", { enumerable: true, get: function () { return __importDefault(toPath_1).default; } });

package/dist/cjs/_internal/isArguments.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isArguments;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+function isObjectLike(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isArgumentsByTag(value) {
+    return Object.prototype.toString.call(value) === '[object Arguments]';
+}
+function isArgumentsByShape(value) {
+    return (isObjectLike(value) &&
+        hasOwnProperty.call(value, 'callee') &&
+        !propertyIsEnumerable.call(value, 'callee'));
+}
+const detectArguments = isArgumentsByTag((function () {
+    // 特征检测须使用 arguments 对象，不能用 rest 参数替代
+    // eslint-disable-next-line prefer-rest-params
+    return arguments;
+})())
+    ? isArgumentsByTag
+    : isArgumentsByShape;
+/**
+ * 判断 value 是否为 `arguments` 对象。
+ *
+ * @internal
+ */
+function isArguments(value) {
+    return detectArguments(value);
+}

package/dist/cjs/_internal/isArrayLike.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isArrayLike;
+const isLength_1 = __importDefault(require("./isLength"));
+/**
+ * 判断 value 是否为类数组（含 length 且非函数）。
+ *
+ * @internal
+ */
+function isArrayLike(value) {
+    return value != null && typeof value !== 'function' && (0, isLength_1.default)(value.length);
+}

package/dist/cjs/_internal/isArrayLikeObject.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isArrayLikeObject;
+const isArrayLike_1 = __importDefault(require("./isArrayLike"));
+/**
+ * 判断 value 是否为类数组对象（排除字符串与函数）。
+ *
+ * @internal
+ */
+function isArrayLikeObject(value) {
+    return typeof value === 'object' && value !== null && (0, isArrayLike_1.default)(value);
+}

package/dist/cjs/_internal/isEmptyValue.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isEmptyValue;
+/**
+ * 表单校验用的「空值」判定：null、undefined、空字符串。
+ *
+ * @internal
+ */
+function isEmptyValue(value) {
+    return value === null || value === undefined || value === '';
+}

package/dist/cjs/_internal/isFlattenable.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isFlattenable;
+const isArguments_1 = __importDefault(require("./isArguments"));
+/**
+ * 判断 value 是否可按 Lodash flatten 规则展开（数组或 arguments）。
+ *
+ * @internal
+ */
+function isFlattenable(value) {
+    return Array.isArray(value) || (0, isArguments_1.default)(value);
+}

package/dist/cjs/_internal/isIndex.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isIndex;
+const RE_IS_UINT = /^(?:0|[1-9]\d*)$/;
+/**
+ * 判断 path 段是否为合法数组下标，与 Lodash isIndex 语义一致。
+ *
+ * @internal
+ */
+function isIndex(value, length) {
+    const max = length !== null && length !== void 0 ? length : Number.MAX_SAFE_INTEGER;
+    if (!max) {
+        return false;
+    }
+    if (typeof value === 'number') {
+        return value > -1 && value % 1 === 0 && value < max;
+    }
+    if (RE_IS_UINT.test(value)) {
+        const index = Number(value);
+        return index > -1 && index % 1 === 0 && index < max;
+    }
+    return false;
+}

package/dist/cjs/_internal/isLength.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isLength;
+const MAX_SAFE_INTEGER = 9007199254740991;
+/**
+ * 判断 value 是否为合法类数组长度。
+ *
+ * @internal
+ */
+function isLength(value) {
+    return (typeof value === 'number' &&
+        value > -1 &&
+        value % 1 === 0 &&
+        value <= MAX_SAFE_INTEGER);
+}

package/dist/cjs/_internal/isPlainObject.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isPlainObject;
+/**
+ * 内部辅助：判断值是否为“纯对象”（由 `{}` 或 `new Object()` 创建，或原型为 null）。
+ *
+ * 该函数仅供库内部复用，不作为公共 API 导出。
+ *
+ * @internal
+ */
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}

package/dist/cjs/_internal/mergeInto.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mergeInto;
+const baseMerge_1 = __importDefault(require("./baseMerge"));
+/**
+ * 内部辅助：将 sources 合并到 object，可选自定义合并器。
+ *
+ * @internal
+ */
+function mergeInto(object, sources, customizer) {
+    let target;
+    if (object == null) {
+        const firstSource = sources.find((source) => source != null);
+        target = Array.isArray(firstSource) ? [] : {};
+    }
+    else if (Array.isArray(object)) {
+        target = object;
+    }
+    else if (typeof object === 'object') {
+        target = object;
+    }
+    else {
+        target = {};
+    }
+    const stack = new Map();
+    for (const source of sources) {
+        (0, baseMerge_1.default)(target, source, customizer, stack);
+    }
+    return target;
+}

package/dist/cjs/_internal/repeatString.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = repeatString;
+/**
+ * 内部辅助：将字符串重复 n 次。
+ *
+ * @internal
+ */
+function repeatString(string, count) {
+    const normalizedCount = Math.trunc(Number(count) || 0);
+    if (normalizedCount < 1) {
+        return '';
+    }
+    return string.repeat(normalizedCount);
+}