es-toolkit 1.34.1-dev.1158 → 1.34.1-dev.1159

package/dist/_chunk/{isPromise-CJHbQD.js → isPromise-ByAybB.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const isPlainObject = require('./isPlainObject-DwqRvh.js');
+const isPlainObject = require('./isPlainObject-Xaozpc.js');
 const noop = require('./noop-2IwLUk.js');
 
 function isLength(value) {

package/dist/_chunk/{toMerged-4hkLjP.js → toSnakeCaseKeys-CDSxES.js}

@@ -1,11 +1,48 @@
 'use strict';
 
-const isPlainObject$1 = require('./isPlainObject-DwqRvh.js');
+const isPlainObject$1 = require('./isPlainObject-Xaozpc.js');
 require('./partialRight-B0_CSB.js');
 const snakeCase = require('./snakeCase-BtVEeB.js');
 
-function isObjectLike(value) {
-    return typeof value === 'object' && value !== null;
+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) {
@@ -159,6 +196,113 @@ 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 omitBy(obj, shouldOmit) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        if (!shouldOmit(value, key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
 function isArray(value) {
     return Array.isArray(value);
 }
@@ -334,74 +478,6 @@ function composeArgs(providedArgs, partialArgs) {
 const curryRightPlaceholder = Symbol('curryRight.placeholder');
 curryRight.placeholder = curryRightPlaceholder;
 
-function findKey(obj, predicate) {
-    const keys = Object.keys(obj);
-    return keys.find(key => predicate(obj[key], key, obj));
-}
-
-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 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 isPlainObject(object) {
     if (typeof object !== 'object') {
         return false;
@@ -430,135 +506,48 @@ function isPlainObject(object) {
     return Object.getPrototypeOf(object) === proto;
 }
 
-function camelizeKeys(obj) {
+function toCamelCaseKeys(obj) {
     if (isArray(obj)) {
-        return obj.map(item => camelizeKeys(item));
+        return obj.map(item => toCamelCaseKeys(item));
     }
     else if (isPlainObject(obj)) {
         const result = {};
-        const defaultObjectKeys = new Set(Object.getOwnPropertyNames(Object.prototype));
-        const plainObject = obj;
-        const keys = Object.keys(plainObject);
+        const keys = Object.keys(obj);
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
-            if (defaultObjectKeys.has(key)) {
-                result[key] = plainObject[key];
-                continue;
-            }
             const camelKey = snakeCase.camelCase(key);
-            result[camelKey] = camelizeKeys(plainObject[key]);
+            const camelCaseKeys = toCamelCaseKeys(obj[key]);
+            result[camelKey] = camelCaseKeys;
         }
         return result;
     }
     return 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 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 omitBy(obj, shouldOmit) {
-    const result = {};
-    const keys = Object.keys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        if (!shouldOmit(value, key)) {
-            result[key] = value;
-        }
-    }
-    return result;
+function toMerged(target, source) {
+    return merge(cloneDeep(target), source);
 }
 
-function snakeizeKeys(obj) {
+function toSnakeCaseKeys(obj) {
     if (isArray(obj)) {
-        return obj.map(item => snakeizeKeys(item));
+        return obj.map(item => toSnakeCaseKeys(item));
     }
     else if (isPlainObject(obj)) {
         const result = {};
-        const plainObject = obj;
-        const defaultObjectKeys = new Set(Object.getOwnPropertyNames(Object.prototype));
-        const keys = Object.keys(plainObject);
+        const keys = Object.keys(obj);
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
-            if (defaultObjectKeys.has(key)) {
-                result[key] = plainObject[key];
-                continue;
-            }
             const snakeKey = snakeCase.snakeCase(key);
-            result[snakeKey] = snakeizeKeys(plainObject[key]);
+            const snakeCaseKeys = toSnakeCaseKeys(obj[key]);
+            result[snakeKey] = snakeCaseKeys;
         }
         return result;
     }
     return obj;
 }
 
-function toMerged(target, source) {
-    return merge(cloneDeep(target), source);
-}
-
 exports.bind = bind;
 exports.bindKey = bindKey;
-exports.camelizeKeys = camelizeKeys;
 exports.clone = clone;
 exports.cloneDeep = cloneDeep;
 exports.cloneDeepWith = cloneDeepWith;
@@ -575,5 +564,6 @@ exports.mapKeys = mapKeys;
 exports.mapValues = mapValues;
 exports.merge = merge;
 exports.omitBy = omitBy;
-exports.snakeizeKeys = snakeizeKeys;
+exports.toCamelCaseKeys = toCamelCaseKeys;
 exports.toMerged = toMerged;
+exports.toSnakeCaseKeys = toSnakeCaseKeys;