es-toolkit 1.13.1 → 1.14.0-dev.399

package/dist/math/index.js

@@ -1,140 +1,83 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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/math/index.ts
-var math_exports = {};
-__export(math_exports, {
-  clamp: () => clamp,
-  inRange: () => inRange,
-  mean: () => mean,
-  meanBy: () => meanBy,
-  random: () => random,
-  randomInt: () => randomInt,
-  range: () => range,
-  round: () => round,
-  sum: () => sum,
-  sumBy: () => sumBy
-});
-module.exports = __toCommonJS(math_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 
-// src/math/clamp.ts
 function clamp(value, bound1, bound2) {
-  if (bound2 == null) {
-    return Math.min(value, bound1);
-  }
-  return Math.min(Math.max(value, bound1), bound2);
+    if (bound2 == null) {
+        return Math.min(value, bound1);
+    }
+    return Math.min(Math.max(value, bound1), bound2);
 }
 
-// src/math/inRange.ts
 function inRange(value, minimum, maximum) {
-  if (maximum == null) {
-    maximum = minimum;
-    minimum = 0;
-  }
-  if (minimum >= maximum) {
-    throw new Error("The maximum value must be greater than the minimum value.");
-  }
-  return minimum <= value && value < maximum;
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('The maximum value must be greater than the minimum value.');
+    }
+    return minimum <= value && value < maximum;
 }
 
-// src/math/sum.ts
 function sum(nums) {
-  let result = 0;
-  for (let i = 0; i < nums.length; i++) {
-    result += nums[i];
-  }
-  return result;
+    let result = 0;
+    for (let i = 0; i < nums.length; i++) {
+        result += nums[i];
+    }
+    return result;
 }
 
-// src/math/mean.ts
 function mean(nums) {
-  return sum(nums) / nums.length;
+    return sum(nums) / nums.length;
 }
 
-// src/math/meanBy.ts
 function meanBy(items, getValue) {
-  const nums = items.map((x) => getValue(x));
-  return mean(nums);
-}
-
-// src/math/random.ts
-function random(minimum, maximum) {
-  if (maximum == null) {
-    maximum = minimum;
-    minimum = 0;
-  }
-  if (minimum >= maximum) {
-    throw new Error("Invalid input: The maximum value must be greater than the minimum value.");
-  }
-  return Math.random() * (maximum - minimum) + minimum;
+    const nums = items.map(x => getValue(x));
+    return mean(nums);
 }
 
-// src/math/randomInt.ts
-function randomInt(minimum, maximum) {
-  return Math.floor(random(minimum, maximum));
-}
-
-// src/math/round.ts
 function round(value, precision = 0) {
-  if (!Number.isInteger(precision)) {
-    throw new Error("Precision must be an integer.");
-  }
-  const multiplier = Math.pow(10, precision);
-  return Math.round(value * multiplier) / multiplier;
+    if (!Number.isInteger(precision)) {
+        throw new Error('Precision must be an integer.');
+    }
+    const multiplier = Math.pow(10, precision);
+    return Math.round(value * multiplier) / multiplier;
 }
 
-// src/math/sumBy.ts
 function sumBy(items, getValue) {
-  const nums = items.map((x) => getValue(x));
-  return sum(nums);
+    const nums = items.map(x => getValue(x));
+    return sum(nums);
 }
 
-// src/math/range.ts
 function range(start, end, step) {
-  if (end == null) {
-    end = start;
-    start = 0;
-  }
-  if (step == null) {
-    step = 1;
-  }
-  if (!Number.isInteger(step) || step === 0) {
-    throw new Error(`The step value must be a non-zero integer.`);
-  }
-  const length = Math.max(Math.ceil((end - start) / step), 0);
-  const result = new Array(length);
-  for (let i = 0; i < length; i++) {
-    result[i] = start + i * step;
-  }
-  return result;
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (step == null) {
+        step = 1;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + i * step;
+    }
+    return result;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  clamp,
-  inRange,
-  mean,
-  meanBy,
-  random,
-  randomInt,
-  range,
-  round,
-  sum,
-  sumBy
-});
-//# sourceMappingURL=index.js.map
+
+exports.random = randomInt.random;
+exports.randomInt = randomInt.randomInt;
+exports.clamp = clamp;
+exports.inRange = inRange;
+exports.mean = mean;
+exports.meanBy = meanBy;
+exports.range = range;
+exports.round = round;
+exports.sum = sum;
+exports.sumBy = sumBy;

package/dist/math/index.mjs

@@ -1,45 +1,10 @@
-import "../chunk-FUS75PJ7.mjs";
-import {
-  round
-} from "../chunk-5PMKOZ2F.mjs";
-import {
-  sumBy
-} from "../chunk-5L4VWRFX.mjs";
-import {
-  clamp
-} from "../chunk-MLCL773E.mjs";
-import {
-  inRange
-} from "../chunk-BH6HLGBA.mjs";
-import {
-  meanBy
-} from "../chunk-MY4G7R3I.mjs";
-import {
-  mean
-} from "../chunk-5ASRKEB4.mjs";
-import {
-  sum
-} from "../chunk-2SLTL4KL.mjs";
-import {
-  range
-} from "../chunk-DPH2KE6O.mjs";
-import {
-  randomInt
-} from "../chunk-GIWAOOFY.mjs";
-import {
-  random
-} from "../chunk-SYWMYQYJ.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  clamp,
-  inRange,
-  mean,
-  meanBy,
-  random,
-  randomInt,
-  range,
-  round,
-  sum,
-  sumBy
-};
-//# sourceMappingURL=index.mjs.map
+export { clamp } from './clamp.mjs';
+export { inRange } from './inRange.mjs';
+export { mean } from './mean.mjs';
+export { meanBy } from './meanBy.mjs';
+export { random } from './random.mjs';
+export { randomInt } from './randomInt.mjs';
+export { round } from './round.mjs';
+export { sum } from './sum.mjs';
+export { sumBy } from './sumBy.mjs';
+export { range } from './range.mjs';

package/dist/math/mean.mjs

@@ -1,9 +1,7 @@
-import {
-  mean
-} from "../chunk-5ASRKEB4.mjs";
-import "../chunk-2SLTL4KL.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  mean
-};
-//# sourceMappingURL=mean.mjs.map
+import { sum } from './sum.mjs';
+
+function mean(nums) {
+    return sum(nums) / nums.length;
+}
+
+export { mean };

package/dist/math/meanBy.mjs

@@ -1,10 +1,8 @@
-import {
-  meanBy
-} from "../chunk-MY4G7R3I.mjs";
-import "../chunk-5ASRKEB4.mjs";
-import "../chunk-2SLTL4KL.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  meanBy
-};
-//# sourceMappingURL=meanBy.mjs.map
+import { mean } from './mean.mjs';
+
+function meanBy(items, getValue) {
+    const nums = items.map(x => getValue(x));
+    return mean(nums);
+}
+
+export { meanBy };

package/dist/math/random.mjs

@@ -1,8 +1,12 @@
-import {
-  random
-} from "../chunk-SYWMYQYJ.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  random
-};
-//# sourceMappingURL=random.mjs.map
+function random(minimum, maximum) {
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('Invalid input: The maximum value must be greater than the minimum value.');
+    }
+    return Math.random() * (maximum - minimum) + minimum;
+}
+
+export { random };

package/dist/math/randomInt.mjs

@@ -1,9 +1,7 @@
-import {
-  randomInt
-} from "../chunk-GIWAOOFY.mjs";
-import "../chunk-SYWMYQYJ.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  randomInt
-};
-//# sourceMappingURL=randomInt.mjs.map
+import { random } from './random.mjs';
+
+function randomInt(minimum, maximum) {
+    return Math.floor(random(minimum, maximum));
+}
+
+export { randomInt };

package/dist/math/range.mjs

@@ -1,8 +1,20 @@
-import {
-  range
-} from "../chunk-DPH2KE6O.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  range
-};
-//# sourceMappingURL=range.mjs.map
+function range(start, end, step) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (step == null) {
+        step = 1;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + i * step;
+    }
+    return result;
+}
+
+export { range };

package/dist/math/round.mjs

@@ -1,8 +1,9 @@
-import {
-  round
-} from "../chunk-5PMKOZ2F.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  round
-};
-//# sourceMappingURL=round.mjs.map
+function round(value, precision = 0) {
+    if (!Number.isInteger(precision)) {
+        throw new Error('Precision must be an integer.');
+    }
+    const multiplier = Math.pow(10, precision);
+    return Math.round(value * multiplier) / multiplier;
+}
+
+export { round };

package/dist/math/sum.mjs

@@ -1,8 +1,9 @@
-import {
-  sum
-} from "../chunk-2SLTL4KL.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  sum
-};
-//# sourceMappingURL=sum.mjs.map
+function sum(nums) {
+    let result = 0;
+    for (let i = 0; i < nums.length; i++) {
+        result += nums[i];
+    }
+    return result;
+}
+
+export { sum };

package/dist/math/sumBy.mjs

@@ -1,9 +1,8 @@
-import {
-  sumBy
-} from "../chunk-5L4VWRFX.mjs";
-import "../chunk-2SLTL4KL.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  sumBy
-};
-//# sourceMappingURL=sumBy.mjs.map
+import { sum } from './sum.mjs';
+
+function sumBy(items, getValue) {
+    const nums = items.map(x => getValue(x));
+    return sum(nums);
+}
+
+export { sumBy };

package/dist/object/clone.mjs

@@ -1,8 +1,39 @@
-import {
-  clone
-} from "../chunk-U4JGKZ56.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  clone
-};
-//# sourceMappingURL=clone.mjs.map
+function clone(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;
+}
+function isPrimitive(value) {
+    return value == null || (typeof value !== 'object' && typeof value !== 'function');
+}
+
+export { clone };

package/dist/object/cloneDeep.d.mts

@@ -0,0 +1,49 @@
+/**
+ * Creates a deep clone of the given object.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to clone.
+ * @returns {T} - A deep clone of the given object.
+ *
+ * @example
+ * // Clone a primitive values
+ * const num = 29;
+ * const clonedNum = clone(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * @example
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = clone(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an array with nested objects
+ * const arr = [1, { a: 1 }, [1, 2, 3]];
+ * const clonedArr = clone(arr);
+ * arr[1].a = 2;
+ * console.log(arr); // [2, { a: 2 }, [1, 2, 3]]
+ * console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = clone(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ *
+ * @example
+ * // Clone an object with nested objects
+ * const obj = { a: 1, b: { c: 1 } };
+ * const clonedObj = clone(obj);
+ * obj.b.c = 2;
+ * console.log(obj); // { a: 1, b: { c: 2 } }
+ * console.log(clonedObj); // { a: 1, b: { c: 1 } }
+ * console.log(clonedObj === obj); // false
+ */
+declare function cloneDeep<T>(obj: T): T;
+
+export { cloneDeep };

package/dist/object/cloneDeep.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Creates a deep clone of the given object.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to clone.
+ * @returns {T} - A deep clone of the given object.
+ *
+ * @example
+ * // Clone a primitive values
+ * const num = 29;
+ * const clonedNum = clone(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * @example
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = clone(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an array with nested objects
+ * const arr = [1, { a: 1 }, [1, 2, 3]];
+ * const clonedArr = clone(arr);
+ * arr[1].a = 2;
+ * console.log(arr); // [2, { a: 2 }, [1, 2, 3]]
+ * console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = clone(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ *
+ * @example
+ * // Clone an object with nested objects
+ * const obj = { a: 1, b: { c: 1 } };
+ * const clonedObj = clone(obj);
+ * obj.b.c = 2;
+ * console.log(obj); // { a: 1, b: { c: 2 } }
+ * console.log(clonedObj); // { a: 1, b: { c: 1 } }
+ * console.log(clonedObj === obj); // false
+ */
+declare function cloneDeep<T>(obj: T): T;
+
+export { cloneDeep };

package/dist/object/cloneDeep.mjs

@@ -0,0 +1,113 @@
+import { isPrimitive } from '../predicate/isPrimitive.mjs';
+import { isTypedArray } from '../predicate/isTypedArray.mjs';
+
+function cloneDeep(obj) {
+    return cloneDeepImpl(obj);
+}
+function cloneDeepImpl(obj, stack = new Map()) {
+    if (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(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;
+}
+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);
+        }
+    }
+}
+
+export { cloneDeep, copyProperties };