es-toolkit 1.13.1 → 1.14.0-dev.399

package/dist/object/flattenObject.mjs

@@ -1,9 +1,28 @@
-import {
-  flattenObject
-} from "../chunk-XGQWTHW6.mjs";
-import "../chunk-MIGAC7F4.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  flattenObject
-};
-//# sourceMappingURL=flattenObject.mjs.map
+import { isPlainObject } from '../predicate/isPlainObject.mjs';
+
+function flattenObject(object) {
+    return flattenObjectImpl(object);
+}
+function flattenObjectImpl(object, prefix = '') {
+    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}.${key}` : key;
+        if (isPlainObject(value) && Object.keys(value).length > 0) {
+            Object.assign(result, flattenObjectImpl(value, prefixedKey));
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index++) {
+                result[`${prefixedKey}.${index}`] = value[index];
+            }
+            continue;
+        }
+        result[prefixedKey] = value;
+    }
+    return result;
+}
+
+export { flattenObject };

package/dist/object/index.d.mts

@@ -5,3 +5,6 @@ export { pickBy } from './pickBy.mjs';
 export { invert } from './invert.mjs';
 export { clone } from './clone.mjs';
 export { flattenObject } from './flattenObject.mjs';
+export { mapKeys } from './mapKeys.mjs';
+export { mapValues } from './mapValues.mjs';
+export { cloneDeep } from './cloneDeep.mjs';

package/dist/object/index.d.ts

@@ -5,3 +5,6 @@ export { pickBy } from './pickBy.js';
 export { invert } from './invert.js';
 export { clone } from './clone.js';
 export { flattenObject } from './flattenObject.js';
+export { mapKeys } from './mapKeys.js';
+export { mapValues } from './mapValues.js';
+export { cloneDeep } from './cloneDeep.js';

package/dist/object/index.js

@@ -1,194 +1,259 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/object/index.ts
-var object_exports = {};
-__export(object_exports, {
-  clone: () => clone,
-  flattenObject: () => flattenObject,
-  invert: () => invert,
-  omit: () => omit,
-  omitBy: () => omitBy,
-  pick: () => pick,
-  pickBy: () => pickBy
-});
-module.exports = __toCommonJS(object_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const isTypedArray = require('../_chunk/isTypedArray-BBEkFl.js');
 
-// src/object/omit.ts
 function omit(obj, keys) {
-  const result = __spreadValues({}, obj);
-  for (const key of keys) {
-    delete result[key];
-  }
-  return result;
+    const result = { ...obj };
+    for (const key of keys) {
+        delete result[key];
+    }
+    return result;
 }
 
-// src/object/omitBy.ts
 function omitBy(obj, shouldOmit) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (shouldOmit(value, key)) {
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (shouldOmit(value, key)) {
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
 }
 
-// src/object/pick.ts
 function pick(obj, keys) {
-  const result = {};
-  for (const key of keys) {
-    result[key] = obj[key];
-  }
-  return result;
+    const result = {};
+    for (const key of keys) {
+        result[key] = obj[key];
+    }
+    return result;
 }
 
-// src/object/pickBy.ts
 function pickBy(obj, shouldPick) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (!shouldPick(value, key)) {
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (!shouldPick(value, key)) {
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
 }
 
-// src/object/invert.ts
 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;
+    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;
 }
 
-// src/object/clone.ts
 function clone(obj) {
-  if (isPrimitive(obj)) {
+    if (isPrimitive(obj)) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.slice();
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof RegExp) {
+        return new RegExp(obj.source, obj.flags);
+    }
+    if (obj instanceof Map) {
+        const result = new Map();
+        for (const [key, value] of obj) {
+            result.set(key, value);
+        }
+        return result;
+    }
+    if (obj instanceof Set) {
+        const result = new Set();
+        for (const value of obj) {
+            result.add(value);
+        }
+        return result;
+    }
+    if (typeof obj === 'object') {
+        const prototype = Object.getPrototypeOf(obj);
+        const result = Object.create(prototype);
+        return Object.assign(result, obj);
+    }
     return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.slice();
-  }
-  if (obj instanceof Date) {
-    return new Date(obj.getTime());
-  }
-  if (obj instanceof RegExp) {
-    return new RegExp(obj.source, obj.flags);
-  }
-  if (obj instanceof Map) {
-    const result = /* @__PURE__ */ new Map();
-    for (const [key, value] of obj) {
-      result.set(key, value);
+}
+function isPrimitive(value) {
+    return value == null || (typeof value !== 'object' && typeof value !== 'function');
+}
+
+function flattenObject(object) {
+    return flattenObjectImpl(object);
+}
+function flattenObjectImpl(object, prefix = '') {
+    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}.${key}` : key;
+        if (isTypedArray.isPlainObject(value) && Object.keys(value).length > 0) {
+            Object.assign(result, flattenObjectImpl(value, prefixedKey));
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index++) {
+                result[`${prefixedKey}.${index}`] = value[index];
+            }
+            continue;
+        }
+        result[prefixedKey] = value;
     }
     return result;
-  }
-  if (obj instanceof Set) {
-    const result = /* @__PURE__ */ new Set();
-    for (const value of obj) {
-      result.add(value);
+}
+
+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;
-  }
-  if (typeof obj === "object") {
-    return Object.assign({}, obj);
-  }
-  return obj;
-}
-function isPrimitive(value) {
-  return value == null || typeof value !== "object" && typeof value !== "function";
 }
 
-// src/predicate/isPlainObject.ts
-function isPlainObject(object) {
-  if (typeof object !== "object") {
-    return false;
-  }
-  if (object == null) {
-    return false;
-  }
-  if (Object.getPrototypeOf(object) === null) {
-    return true;
-  }
-  if (object.toString() !== "[object Object]") {
-    return false;
-  }
-  let proto = object;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
-  }
-  return Object.getPrototypeOf(object) === proto;
+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;
 }
 
-// src/object/flattenObject.ts
-function flattenObject(object) {
-  return flattenObjectImpl(object);
+function cloneDeep(obj) {
+    return cloneDeepImpl(obj);
 }
-function flattenObjectImpl(object, prefix = "") {
-  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}.${key}` : key;
-    if (isPlainObject(value) && Object.keys(value).length > 0) {
-      Object.assign(result, flattenObjectImpl(value, prefixedKey));
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (let index = 0; index < value.length; index++) {
-        result[`${prefixedKey}.${index}`] = value[index];
-      }
-      continue;
-    }
-    result[prefixedKey] = value;
-  }
-  return result;
+function cloneDeepImpl(obj, stack = new Map()) {
+    if (isTypedArray.isPrimitive(obj)) {
+        return obj;
+    }
+    if (stack.has(obj)) {
+        return stack.get(obj);
+    }
+    if (Array.isArray(obj)) {
+        const result = new Array(obj.length);
+        stack.set(obj, result);
+        for (let i = 0; i < obj.length; i++) {
+            result[i] = cloneDeepImpl(obj[i], stack);
+        }
+        if (Object.prototype.hasOwnProperty.call(obj, 'index')) {
+            result.index = obj.index;
+        }
+        if (Object.prototype.hasOwnProperty.call(obj, 'input')) {
+            result.input = obj.input;
+        }
+        return result;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof RegExp) {
+        const result = new RegExp(obj.source, obj.flags);
+        result.lastIndex = obj.lastIndex;
+        return result;
+    }
+    if (obj instanceof Map) {
+        const result = new Map();
+        stack.set(obj, result);
+        for (const [key, value] of obj.entries()) {
+            result.set(key, cloneDeepImpl(value, stack));
+        }
+        return result;
+    }
+    if (obj instanceof Set) {
+        const result = new Set();
+        stack.set(obj, result);
+        for (const value of obj.values()) {
+            result.add(cloneDeepImpl(value, stack));
+        }
+        return result;
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(obj)) {
+        return obj.subarray();
+    }
+    if (isTypedArray.isTypedArray(obj)) {
+        const result = new (Object.getPrototypeOf(obj).constructor)(obj.length);
+        stack.set(obj, result);
+        for (let i = 0; i < obj.length; i++) {
+            result[i] = cloneDeepImpl(obj[i], stack);
+        }
+        return result;
+    }
+    if (obj instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && obj instanceof SharedArrayBuffer)) {
+        return obj.slice(0);
+    }
+    if (obj instanceof DataView) {
+        const result = new DataView(obj.buffer.slice(0));
+        stack.set(obj, result);
+        copyProperties(result, obj, stack);
+        return result;
+    }
+    if (typeof File !== 'undefined' && obj instanceof File) {
+        const result = new File([obj], obj.name, { type: obj.type });
+        stack.set(obj, result);
+        copyProperties(result, obj, stack);
+        return result;
+    }
+    if (obj instanceof Blob) {
+        const result = new Blob([obj], { type: obj.type });
+        stack.set(obj, result);
+        copyProperties(result, obj, stack);
+        return result;
+    }
+    if (obj instanceof Error) {
+        const result = new obj.constructor();
+        stack.set(obj, result);
+        result.message = obj.message;
+        result.name = obj.name;
+        result.stack = obj.stack;
+        result.cause = obj.cause;
+        copyProperties(result, obj, stack);
+        return result;
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        const result = {};
+        stack.set(obj, result);
+        copyProperties(result, obj, stack);
+        return result;
+    }
+    return obj;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  clone,
-  flattenObject,
-  invert,
-  omit,
-  omitBy,
-  pick,
-  pickBy
-});
-//# sourceMappingURL=index.js.map
+function copyProperties(target, source, stack) {
+    const keys = Object.keys(source);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor?.writable || descriptor?.set) {
+            target[key] = cloneDeepImpl(source[key], stack);
+        }
+    }
+}
+
+exports.clone = clone;
+exports.cloneDeep = cloneDeep;
+exports.flattenObject = flattenObject;
+exports.invert = invert;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;
+exports.omit = omit;
+exports.omitBy = omitBy;
+exports.pick = pick;
+exports.pickBy = pickBy;

package/dist/object/index.mjs

@@ -1,34 +1,10 @@
-import "../chunk-54TK5BIS.mjs";
-import {
-  omitBy
-} from "../chunk-BCTYOXT7.mjs";
-import {
-  pick
-} from "../chunk-HPFDYUGP.mjs";
-import {
-  pickBy
-} from "../chunk-6CLH5YZ2.mjs";
-import {
-  clone
-} from "../chunk-U4JGKZ56.mjs";
-import {
-  flattenObject
-} from "../chunk-XGQWTHW6.mjs";
-import "../chunk-MIGAC7F4.mjs";
-import {
-  invert
-} from "../chunk-OLX53VEF.mjs";
-import {
-  omit
-} from "../chunk-WFZXCGEG.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  clone,
-  flattenObject,
-  invert,
-  omit,
-  omitBy,
-  pick,
-  pickBy
-};
-//# sourceMappingURL=index.mjs.map
+export { omit } from './omit.mjs';
+export { omitBy } from './omitBy.mjs';
+export { pick } from './pick.mjs';
+export { pickBy } from './pickBy.mjs';
+export { invert } from './invert.mjs';
+export { clone } from './clone.mjs';
+export { flattenObject } from './flattenObject.mjs';
+export { mapKeys } from './mapKeys.mjs';
+export { mapValues } from './mapValues.mjs';
+export { cloneDeep } from './cloneDeep.mjs';

package/dist/object/invert.mjs

@@ -1,8 +1,12 @@
-import {
-  invert
-} from "../chunk-OLX53VEF.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  invert
-};
-//# sourceMappingURL=invert.mjs.map
+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;
+}
+
+export { invert };

package/dist/object/mapKeys.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Creates a new object with the same values as the given object, but with keys generated
+ * by running each own enumerable property of the object through the iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the keys in the object.
+ * @template K2 - The type of the new keys generated by the iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[K1], key: K1, object: T) => K2} getNewKey - The function invoked per own enumerable property.
+ * @returns {Record<K2, T[K1]>} - Returns the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = mapKeys(obj, (value, key) => key + value);
+ * console.log(result); // { a1: 1, b2: 2 }
+ */
+declare function mapKeys<T extends object, K1 extends keyof T, K2 extends PropertyKey>(object: T, getNewKey: (value: T[K1], key: K1, object: T) => K2): Record<K2, T[K1]>;
+
+export { mapKeys };

package/dist/object/mapKeys.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a new object with the same values as the given object, but with keys generated
+ * by running each own enumerable property of the object through the iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the keys in the object.
+ * @template K2 - The type of the new keys generated by the iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[K1], key: K1, object: T) => K2} getNewKey - The function invoked per own enumerable property.
+ * @returns {Record<K2, T[K1]>} - Returns the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = mapKeys(obj, (value, key) => key + value);
+ * console.log(result); // { a1: 1, b2: 2 }
+ */
+declare function mapKeys<T extends object, K1 extends keyof T, K2 extends PropertyKey>(object: T, getNewKey: (value: T[K1], key: K1, object: T) => K2): Record<K2, T[K1]>;
+
+export { mapKeys };

package/dist/object/mapKeys.mjs

@@ -0,0 +1,12 @@
+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;
+}
+
+export { mapKeys };

package/dist/object/mapValues.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Creates a new object with the same keys as the given object, but with values generated
+ * by running each own enumerable property of the object through the iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the keys in the object.
+ * @template V - The type of the new values generated by the iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[K], key: K, object: T) => V} getNewValue - The function invoked per own enumerable property.
+ * @returns {Record<K, V>} - Returns the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = mapValues(obj, (value) => value * 2);
+ * console.log(result); // { a: 2, b: 4 }
+ */
+declare function mapValues<T extends object, K extends keyof T, V>(object: T, getNewValue: (value: T[K], key: K, object: T) => V): Record<K, V>;
+
+export { mapValues };

package/dist/object/mapValues.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a new object with the same keys as the given object, but with values generated
+ * by running each own enumerable property of the object through the iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the keys in the object.
+ * @template V - The type of the new values generated by the iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[K], key: K, object: T) => V} getNewValue - The function invoked per own enumerable property.
+ * @returns {Record<K, V>} - Returns the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = mapValues(obj, (value) => value * 2);
+ * console.log(result); // { a: 2, b: 4 }
+ */
+declare function mapValues<T extends object, K extends keyof T, V>(object: T, getNewValue: (value: T[K], key: K, object: T) => V): Record<K, V>;
+
+export { mapValues };

package/dist/object/mapValues.mjs

@@ -0,0 +1,12 @@
+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;
+}
+
+export { mapValues };