es-toolkit 1.36.0 → 1.37.0-dev.1241

package/dist/_chunk/toSnakeCaseKeys-kqZCyq.js

@@ -0,0 +1,379 @@
+'use strict';
+
+const isPlainObject$1 = require('./isPlainObject-Xaozpc.js');
+const snakeCase = require('./snakeCase-BwvoPi.js');
+
+function clone(obj) {
+    if (isPlainObject$1.isPrimitive(obj)) {
+        return obj;
+    }
+    if (Array.isArray(obj) ||
+        isPlainObject$1.isTypedArray(obj) ||
+        obj instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && obj instanceof SharedArrayBuffer)) {
+        return obj.slice(0);
+    }
+    const prototype = Object.getPrototypeOf(obj);
+    const Constructor = prototype.constructor;
+    if (obj instanceof Date || obj instanceof Map || obj instanceof Set) {
+        return new Constructor(obj);
+    }
+    if (obj instanceof RegExp) {
+        const newRegExp = new Constructor(obj);
+        newRegExp.lastIndex = obj.lastIndex;
+        return newRegExp;
+    }
+    if (obj instanceof DataView) {
+        return new Constructor(obj.buffer.slice(0));
+    }
+    if (obj instanceof Error) {
+        const newError = new Constructor(obj.message);
+        newError.stack = obj.stack;
+        newError.name = obj.name;
+        newError.cause = obj.cause;
+        return newError;
+    }
+    if (typeof File !== 'undefined' && obj instanceof File) {
+        const newFile = new Constructor([obj], obj.name, { type: obj.type, lastModified: obj.lastModified });
+        return newFile;
+    }
+    if (typeof obj === 'object') {
+        const newObject = Object.create(prototype);
+        return Object.assign(newObject, obj);
+    }
+    return obj;
+}
+
+function cloneDeepWith(obj, cloneValue) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), cloneValue);
+}
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) {
+    const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+    if (cloned != null) {
+        return cloned;
+    }
+    if (isPlainObject$1.isPrimitive(valueToClone)) {
+        return valueToClone;
+    }
+    if (stack.has(valueToClone)) {
+        return stack.get(valueToClone);
+    }
+    if (Array.isArray(valueToClone)) {
+        const result = new Array(valueToClone.length);
+        stack.set(valueToClone, result);
+        for (let i = 0; i < valueToClone.length; i++) {
+            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+        }
+        if (Object.hasOwn(valueToClone, 'index')) {
+            result.index = valueToClone.index;
+        }
+        if (Object.hasOwn(valueToClone, 'input')) {
+            result.input = valueToClone.input;
+        }
+        return result;
+    }
+    if (valueToClone instanceof Date) {
+        return new Date(valueToClone.getTime());
+    }
+    if (valueToClone instanceof RegExp) {
+        const result = new RegExp(valueToClone.source, valueToClone.flags);
+        result.lastIndex = valueToClone.lastIndex;
+        return result;
+    }
+    if (valueToClone instanceof Map) {
+        const result = new Map();
+        stack.set(valueToClone, result);
+        for (const [key, value] of valueToClone) {
+            result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+        }
+        return result;
+    }
+    if (valueToClone instanceof Set) {
+        const result = new Set();
+        stack.set(valueToClone, result);
+        for (const value of valueToClone) {
+            result.add(cloneDeepWithImpl(value, undefined, objectToClone, stack, cloneValue));
+        }
+        return result;
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
+        return valueToClone.subarray();
+    }
+    if (isPlainObject$1.isTypedArray(valueToClone)) {
+        const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length);
+        stack.set(valueToClone, result);
+        for (let i = 0; i < valueToClone.length; i++) {
+            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+        }
+        return result;
+    }
+    if (valueToClone instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && valueToClone instanceof SharedArrayBuffer)) {
+        return valueToClone.slice(0);
+    }
+    if (valueToClone instanceof DataView) {
+        const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (typeof File !== 'undefined' && valueToClone instanceof File) {
+        const result = new File([valueToClone], valueToClone.name, {
+            type: valueToClone.type,
+        });
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (valueToClone instanceof Blob) {
+        const result = new Blob([valueToClone], { type: valueToClone.type });
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (valueToClone instanceof Error) {
+        const result = new valueToClone.constructor();
+        stack.set(valueToClone, result);
+        result.message = valueToClone.message;
+        result.name = valueToClone.name;
+        result.stack = valueToClone.stack;
+        result.cause = valueToClone.cause;
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (typeof valueToClone === 'object' && isCloneableObject(valueToClone)) {
+        const result = Object.create(Object.getPrototypeOf(valueToClone));
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+    const keys = [...Object.keys(source), ...isPlainObject$1.getSymbols(source)];
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const descriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (descriptor == null || descriptor.writable) {
+            target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+        }
+    }
+}
+function isCloneableObject(object) {
+    switch (isPlainObject$1.getTag(object)) {
+        case isPlainObject$1.argumentsTag:
+        case isPlainObject$1.arrayTag:
+        case isPlainObject$1.arrayBufferTag:
+        case isPlainObject$1.dataViewTag:
+        case isPlainObject$1.booleanTag:
+        case isPlainObject$1.dateTag:
+        case isPlainObject$1.float32ArrayTag:
+        case isPlainObject$1.float64ArrayTag:
+        case isPlainObject$1.int8ArrayTag:
+        case isPlainObject$1.int16ArrayTag:
+        case isPlainObject$1.int32ArrayTag:
+        case isPlainObject$1.mapTag:
+        case isPlainObject$1.numberTag:
+        case isPlainObject$1.objectTag:
+        case isPlainObject$1.regexpTag:
+        case isPlainObject$1.setTag:
+        case isPlainObject$1.stringTag:
+        case isPlainObject$1.symbolTag:
+        case isPlainObject$1.uint8ArrayTag:
+        case isPlainObject$1.uint8ClampedArrayTag:
+        case isPlainObject$1.uint16ArrayTag:
+        case isPlainObject$1.uint32ArrayTag: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+
+function cloneDeep(obj) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined);
+}
+
+function findKey(obj, predicate) {
+    const keys = Object.keys(obj);
+    return keys.find(key => predicate(obj[key], key, obj));
+}
+
+function flattenObject(object, { delimiter = '.' } = {}) {
+    return flattenObjectImpl(object, '', delimiter);
+}
+function flattenObjectImpl(object, prefix = '', delimiter = '.') {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key;
+        if (isPlainObject$1.isPlainObject(value) && Object.keys(value).length > 0) {
+            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+            continue;
+        }
+        if (Array.isArray(value)) {
+            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+            continue;
+        }
+        result[prefixedKey] = value;
+    }
+    return result;
+}
+
+function invert(obj) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        result[value] = key;
+    }
+    return result;
+}
+
+function mapKeys(object, getNewKey) {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        result[getNewKey(value, key, object)] = value;
+    }
+    return result;
+}
+
+function mapValues(object, getNewValue) {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        result[key] = getNewValue(value, key, object);
+    }
+    return result;
+}
+
+function merge(target, source) {
+    const sourceKeys = Object.keys(source);
+    for (let i = 0; i < sourceKeys.length; i++) {
+        const key = sourceKeys[i];
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (Array.isArray(sourceValue)) {
+            if (Array.isArray(targetValue)) {
+                target[key] = merge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = merge([], sourceValue);
+            }
+        }
+        else if (isPlainObject$1.isPlainObject(sourceValue)) {
+            if (isPlainObject$1.isPlainObject(targetValue)) {
+                target[key] = merge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = merge({}, sourceValue);
+            }
+        }
+        else if (targetValue === undefined || sourceValue !== undefined) {
+            target[key] = sourceValue;
+        }
+    }
+    return target;
+}
+
+function isObjectLike(value) {
+    return typeof value === 'object' && value !== null;
+}
+
+function isArray(value) {
+    return Array.isArray(value);
+}
+
+function toCamelCaseKeys(obj) {
+    if (isArray(obj)) {
+        return obj.map(item => toCamelCaseKeys(item));
+    }
+    if (isPlainObject$1.isPlainObject(obj)) {
+        const result = {};
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const camelKey = snakeCase.camelCase(key);
+            const camelCaseKeys = toCamelCaseKeys(obj[key]);
+            result[camelKey] = camelCaseKeys;
+        }
+        return result;
+    }
+    return obj;
+}
+
+function toMerged(target, source) {
+    return merge(cloneDeep(target), source);
+}
+
+function isPlainObject(object) {
+    if (typeof object !== 'object') {
+        return false;
+    }
+    if (object == null) {
+        return false;
+    }
+    if (Object.getPrototypeOf(object) === null) {
+        return true;
+    }
+    if (Object.prototype.toString.call(object) !== '[object Object]') {
+        const tag = object[Symbol.toStringTag];
+        if (tag == null) {
+            return false;
+        }
+        const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
+        if (isTagReadonly) {
+            return false;
+        }
+        return object.toString() === `[object ${tag}]`;
+    }
+    let proto = object;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(object) === proto;
+}
+
+function toSnakeCaseKeys(obj) {
+    if (isArray(obj)) {
+        return obj.map(item => toSnakeCaseKeys(item));
+    }
+    if (isPlainObject(obj)) {
+        const result = {};
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const snakeKey = snakeCase.snakeCase(key);
+            const snakeCaseKeys = toSnakeCaseKeys(obj[key]);
+            result[snakeKey] = snakeCaseKeys;
+        }
+        return result;
+    }
+    return obj;
+}
+
+exports.clone = clone;
+exports.cloneDeep = cloneDeep;
+exports.cloneDeepWith = cloneDeepWith;
+exports.copyProperties = copyProperties;
+exports.findKey = findKey;
+exports.flattenObject = flattenObject;
+exports.invert = invert;
+exports.isArray = isArray;
+exports.isObjectLike = isObjectLike;
+exports.isPlainObject = isPlainObject;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;
+exports.merge = merge;
+exports.toCamelCaseKeys = toCamelCaseKeys;
+exports.toMerged = toMerged;
+exports.toSnakeCaseKeys = toSnakeCaseKeys;

package/dist/_chunk/{reverseString-BixeGz.js → upperFirst-DbrFSz.js}

@@ -1,21 +1,10 @@
 'use strict';
 
-function capitalize(str) {
-    return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase());
-}
-
-const CASE_SPLIT_PATTERN = /\p{Lu}?\p{Ll}+|[0-9]+|\p{Lu}+(?!\p{Ll})|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu;
-function words(str) {
-    return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
-}
+const snakeCase = require('./snakeCase-BwvoPi.js');
 
-function camelCase(str) {
-    const words$1 = words(str);
-    if (words$1.length === 0) {
-        return '';
-    }
-    const [first, ...rest] = words$1;
-    return `${first.toLowerCase()}${rest.map(word => capitalize(word)).join('')}`;
+function constantCase(str) {
+    const words = snakeCase.words(str);
+    return words.map(word => word.toUpperCase()).join('_');
 }
 
 const deburrMap = new Map(Object.entries({
@@ -78,13 +67,13 @@ function escapeRegExp(str) {
 }
 
 function kebabCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => word.toLowerCase()).join('-');
+    const words = snakeCase.words(str);
+    return words.map(word => word.toLowerCase()).join('-');
 }
 
 function lowerCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => word.toLowerCase()).join(' ');
+    const words = snakeCase.words(str);
+    return words.map(word => word.toLowerCase()).join(' ');
 }
 
 function lowerFirst(str) {
@@ -95,9 +84,13 @@ function pad(str, length, chars = ' ') {
     return str.padStart(Math.floor((length - str.length) / 2) + str.length, chars).padEnd(length, chars);
 }
 
-function snakeCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => word.toLowerCase()).join('_');
+function pascalCase(str) {
+    const words = snakeCase.words(str);
+    return words.map(word => snakeCase.capitalize(word)).join('');
+}
+
+function reverseString(value) {
+    return [...value].reverse().join('');
 }
 
 function trimEnd(str, chars) {
@@ -164,11 +157,11 @@ function unescape(str) {
 }
 
 function upperCase(str) {
-    const words$1 = words(str);
+    const words = snakeCase.words(str);
     let result = '';
-    for (let i = 0; i < words$1.length; i++) {
-        result += words$1[i].toUpperCase();
-        if (i < words$1.length - 1) {
+    for (let i = 0; i < words.length; i++) {
+        result += words[i].toUpperCase();
+        if (i < words.length - 1) {
             result += ' ';
         }
     }
@@ -179,23 +172,6 @@ function upperFirst(str) {
     return str.substring(0, 1).toUpperCase() + str.substring(1);
 }
 
-function constantCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => word.toUpperCase()).join('_');
-}
-
-function pascalCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => capitalize(word)).join('');
-}
-
-function reverseString(value) {
-    return [...value].reverse().join('');
-}
-
-exports.CASE_SPLIT_PATTERN = CASE_SPLIT_PATTERN;
-exports.camelCase = camelCase;
-exports.capitalize = capitalize;
 exports.constantCase = constantCase;
 exports.deburr = deburr;
 exports.escape = escape;
@@ -206,11 +182,9 @@ exports.lowerFirst = lowerFirst;
 exports.pad = pad;
 exports.pascalCase = pascalCase;
 exports.reverseString = reverseString;
-exports.snakeCase = snakeCase;
 exports.trim = trim;
 exports.trimEnd = trimEnd;
 exports.trimStart = trimStart;
 exports.unescape = unescape;
 exports.upperCase = upperCase;
 exports.upperFirst = upperFirst;
-exports.words = words;

package/dist/_chunk/{zip-BJSrRi.js → zip-DDfXXG.js}

@@ -342,10 +342,6 @@ function uniq(arr) {
     return Array.from(new Set(arr));
 }
 
-function union(arr1, arr2) {
-    return uniq(arr1.concat(arr2));
-}
-
 function uniqBy(arr, mapper) {
     const map = new Map();
     for (let i = 0; i < arr.length; i++) {
@@ -395,19 +391,6 @@ function unzip(zipped) {
     return result;
 }
 
-function unzipWith(target, iteratee) {
-    const maxLength = Math.max(...target.map(innerArray => innerArray.length));
-    const result = new Array(maxLength);
-    for (let i = 0; i < maxLength; i++) {
-        const group = new Array(target.length);
-        for (let j = 0; j < target.length; j++) {
-            group[j] = target[j][i];
-        }
-        result[i] = iteratee(...group);
-    }
-    return result;
-}
-
 function windowed(arr, size, step = 1, { partialWindows = false } = {}) {
     if (size <= 0 || !Number.isInteger(size)) {
         throw new Error('Size must be a positive integer.');
@@ -427,10 +410,6 @@ function without(array, ...values) {
     return difference(array, values);
 }
 
-function xor(arr1, arr2) {
-    return difference(union(arr1, arr2), intersection(arr1, arr2));
-}
-
 function xorBy(arr1, arr2, mapper) {
     const union = unionBy(arr1, arr2, mapper);
     const intersection = intersectionBy(arr1, arr2, mapper);
@@ -501,17 +480,14 @@ exports.toFilled = toFilled;
 exports.toFinite = toFinite;
 exports.toInteger = toInteger;
 exports.toNumber = toNumber;
-exports.union = union;
 exports.unionBy = unionBy;
 exports.unionWith = unionWith;
 exports.uniq = uniq;
 exports.uniqBy = uniqBy;
 exports.uniqWith = uniqWith;
 exports.unzip = unzip;
-exports.unzipWith = unzipWith;
 exports.windowed = windowed;
 exports.without = without;
-exports.xor = xor;
 exports.xorBy = xorBy;
 exports.xorWith = xorWith;
 exports.zip = zip;

package/dist/array/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zip = require('../_chunk/zip-BJSrRi.js');
+const zip = require('../_chunk/zip-DDfXXG.js');
 
 function at(arr, indices) {
     const result = new Array(indices.length);
@@ -106,6 +106,27 @@ function takeWhile(arr, shouldContinueTaking) {
     return result;
 }
 
+function union(arr1, arr2) {
+    return zip.uniq(arr1.concat(arr2));
+}
+
+function unzipWith(target, iteratee) {
+    const maxLength = Math.max(...target.map(innerArray => innerArray.length));
+    const result = new Array(maxLength);
+    for (let i = 0; i < maxLength; i++) {
+        const group = new Array(target.length);
+        for (let j = 0; j < target.length; j++) {
+            group[j] = target[j][i];
+        }
+        result[i] = iteratee(...group);
+    }
+    return result;
+}
+
+function xor(arr1, arr2) {
+    return zip.difference(union(arr1, arr2), zip.intersection(arr1, arr2));
+}
+
 function zipObject(keys, values) {
     const result = {};
     for (let i = 0; i < keys.length; i++) {
@@ -161,17 +182,14 @@ exports.tail = zip.tail;
 exports.take = zip.take;
 exports.takeRight = zip.takeRight;
 exports.toFilled = zip.toFilled;
-exports.union = zip.union;
 exports.unionBy = zip.unionBy;
 exports.unionWith = zip.unionWith;
 exports.uniq = zip.uniq;
 exports.uniqBy = zip.uniqBy;
 exports.uniqWith = zip.uniqWith;
 exports.unzip = zip.unzip;
-exports.unzipWith = zip.unzipWith;
 exports.windowed = zip.windowed;
 exports.without = zip.without;
-exports.xor = zip.xor;
 exports.xorBy = zip.xorBy;
 exports.xorWith = zip.xorWith;
 exports.zip = zip.zip;
@@ -184,5 +202,8 @@ exports.pullAt = pullAt;
 exports.sortBy = sortBy;
 exports.takeRightWhile = takeRightWhile;
 exports.takeWhile = takeWhile;
+exports.union = union;
+exports.unzipWith = unzipWith;
+exports.xor = xor;
 exports.zipObject = zipObject;
 exports.zipWith = zipWith;