es-toolkit 1.13.1 → 1.14.0-dev.397

package/dist/_chunk/isFunction-Cw_tLG.js

@@ -0,0 +1,246 @@
+'use strict';
+
+const isTypedArray = require('./isTypedArray-BBEkFl.js');
+
+const regexpTag = '[object RegExp]';
+const stringTag = '[object String]';
+const numberTag = '[object Number]';
+const booleanTag = '[object Boolean]';
+const argumentsTag = '[object Arguments]';
+const symbolTag = '[object Symbol]';
+const dateTag = '[object Date]';
+const mapTag = '[object Map]';
+const setTag = '[object Set]';
+const arrayTag = '[object Array]';
+const functionTag = '[object Function]';
+const arrayBufferTag = '[object ArrayBuffer]';
+const objectTag = '[object Object]';
+const errorTag = '[object Error]';
+const dataViewTag = '[object DataView]';
+const uint8ArrayTag = '[object Uint8Array]';
+const uint8ClampedArrayTag = '[object Uint8ClampedArray]';
+const uint16ArrayTag = '[object Uint16Array]';
+const uint32ArrayTag = '[object Uint32Array]';
+const bigUint64ArrayTag = '[object BigUint64Array]';
+const int8ArrayTag = '[object Int8Array]';
+const int16ArrayTag = '[object Int16Array]';
+const int32ArrayTag = '[object Int32Array]';
+const bigInt64ArrayTag = '[object BigInt64Array]';
+const float32ArrayTag = '[object Float32Array]';
+const float64ArrayTag = '[object Float64Array]';
+
+function getSymbols(object) {
+    return Object.getOwnPropertySymbols(object)
+        .filter(symbol => object.propertyIsEnumerable(symbol));
+}
+
+function getTag(value) {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return Object.prototype.toString.call(value);
+}
+
+function isEqual(a, b) {
+    if (typeof a === typeof b) {
+        switch (typeof a) {
+            case 'bigint':
+            case 'string':
+            case 'boolean':
+            case 'symbol':
+            case 'undefined': {
+                return a === b;
+            }
+            case 'number': {
+                return a === b || Object.is(a, b);
+            }
+            case 'function': {
+                return a === b;
+            }
+            case 'object': {
+                return areObjectsEqual(a, b);
+            }
+        }
+    }
+    return areObjectsEqual(a, b);
+}
+function areObjectsEqual(a, b, stack) {
+    if (Object.is(a, b)) {
+        return true;
+    }
+    let aTag = getTag(a);
+    let bTag = getTag(b);
+    if (aTag === argumentsTag) {
+        aTag = objectTag;
+    }
+    if (bTag === argumentsTag) {
+        bTag = objectTag;
+    }
+    if (aTag !== bTag) {
+        return false;
+    }
+    switch (aTag) {
+        case stringTag:
+            return a.toString() === b.toString();
+        case numberTag: {
+            const x = a.valueOf();
+            const y = b.valueOf();
+            return x === y || Number.isNaN(x) && Number.isNaN(y);
+        }
+        case booleanTag:
+        case dateTag:
+        case symbolTag:
+            return Object.is(a.valueOf(), b.valueOf());
+        case regexpTag: {
+            return a.source === b.source && a.flags === b.flags;
+        }
+        case functionTag: {
+            return a == b;
+        }
+    }
+    stack = stack ?? new Map();
+    const aStack = stack.get(a);
+    const bStack = stack.get(b);
+    if (aStack != null && bStack != null) {
+        return aStack === b;
+    }
+    stack.set(a, b);
+    stack.set(b, a);
+    try {
+        switch (aTag) {
+            case mapTag: {
+                if (a.size !== b.size) {
+                    return false;
+                }
+                for (const [key, value] of a.entries()) {
+                    if (!b.has(key) || !areObjectsEqual(value, b.get(key), stack)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            case setTag: {
+                if (a.size !== b.size) {
+                    return false;
+                }
+                const aValues = Array.from(a.values());
+                const bValues = Array.from(b.values());
+                for (let i = 0; i < aValues.length; i++) {
+                    const aValue = aValues[i];
+                    const index = bValues.findIndex(bValue => {
+                        return areObjectsEqual(aValue, bValue, stack);
+                    });
+                    if (index === -1) {
+                        return false;
+                    }
+                    bValues.splice(index, 1);
+                }
+                return true;
+            }
+            case arrayTag:
+            case uint8ArrayTag:
+            case uint8ClampedArrayTag:
+            case uint16ArrayTag:
+            case uint32ArrayTag:
+            case bigUint64ArrayTag:
+            case int8ArrayTag:
+            case int16ArrayTag:
+            case int32ArrayTag:
+            case bigInt64ArrayTag:
+            case float32ArrayTag:
+            case float64ArrayTag: {
+                if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
+                    return false;
+                }
+                if (a.length !== b.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.length; i++) {
+                    if (!areObjectsEqual(a[i], b[i], stack)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            case arrayBufferTag: {
+                if (a.byteLength !== b.byteLength) {
+                    return false;
+                }
+                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack);
+            }
+            case dataViewTag: {
+                if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
+                    return false;
+                }
+                return areObjectsEqual(a.buffer, b.buffer, stack);
+            }
+            case errorTag: {
+                return a.name === b.name && a.message === b.message;
+            }
+            case objectTag: {
+                const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack) ||
+                    (isTypedArray.isPlainObject(a) && isTypedArray.isPlainObject(b));
+                if (!areEqualInstances) {
+                    return false;
+                }
+                const aKeys = [...Object.keys(a), ...getSymbols(a)];
+                const bKeys = [...Object.keys(b), ...getSymbols(b)];
+                if (aKeys.length !== bKeys.length) {
+                    return false;
+                }
+                for (let i = 0; i < aKeys.length; i++) {
+                    const propKey = aKeys[i];
+                    const aProp = a[propKey];
+                    if (!b.hasOwnProperty(propKey)) {
+                        return false;
+                    }
+                    const bProp = b[propKey];
+                    if (!areObjectsEqual(aProp, bProp, stack)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+    finally {
+        stack.delete(a);
+        stack.delete(b);
+    }
+}
+
+function isNil(x) {
+    return x == null;
+}
+
+function isNotNil(x) {
+    return x !== null && x !== undefined;
+}
+
+function isNull(x) {
+    return x === null;
+}
+
+function isUndefined(x) {
+    return x === undefined;
+}
+
+function isLength(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+exports.getTag = getTag;
+exports.isEqual = isEqual;
+exports.isFunction = isFunction;
+exports.isLength = isLength;
+exports.isNil = isNil;
+exports.isNotNil = isNotNil;
+exports.isNull = isNull;
+exports.isUndefined = isUndefined;

package/dist/_chunk/isTypedArray-BBEkFl.js

@@ -0,0 +1,43 @@
+'use strict';
+
+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 isPrimitive(value) {
+    return value == null || (typeof value !== 'object' && typeof value !== 'function');
+}
+
+function isTypedArray(x) {
+    return (x instanceof Uint8Array ||
+        x instanceof Uint8ClampedArray ||
+        x instanceof Uint16Array ||
+        x instanceof Uint32Array ||
+        x instanceof BigUint64Array ||
+        x instanceof Int8Array ||
+        x instanceof Int16Array ||
+        x instanceof Int32Array ||
+        x instanceof BigInt64Array ||
+        x instanceof Float32Array ||
+        x instanceof Float64Array);
+}
+
+exports.isPlainObject = isPlainObject;
+exports.isPrimitive = isPrimitive;
+exports.isTypedArray = isTypedArray;

package/dist/_chunk/randomInt-CF7bZK.js

@@ -0,0 +1,19 @@
+'use strict';
+
+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;
+}
+
+function randomInt(minimum, maximum) {
+    return Math.floor(random(minimum, maximum));
+}
+
+exports.random = random;
+exports.randomInt = randomInt;

package/dist/array/chunk.mjs

@@ -1,8 +1,15 @@
-import {
-  chunk
-} from "../chunk-E6C5EZQA.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  chunk
-};
-//# sourceMappingURL=chunk.mjs.map
+function chunk(arr, size) {
+    if (!Number.isInteger(size) || size <= 0) {
+        throw new Error('Size must be an integer greater than zero.');
+    }
+    const chunkLength = Math.ceil(arr.length / size);
+    const result = Array(chunkLength);
+    for (let index = 0; index < chunkLength; index++) {
+        const start = index * size;
+        const end = start + size;
+        result[index] = arr.slice(start, end);
+    }
+    return result;
+}
+
+export { chunk };

package/dist/array/compact.d.mts

@@ -3,7 +3,7 @@ type NotFalsey<T> = Exclude<T, false | null | 0 | '' | undefined>;
  * Removes falsey values (false, null, 0, '', undefined, NaN) from an array.
  *
  * @template T - The type of elements in the array.
- * @param {readonly T[]} arr - The input array to remove falsey values.
+ * @param {T[]} arr - The input array to remove falsey values.
  * @returns {Array<Exclude<T, false | null | 0 | '' | undefined>>} - A new array with all falsey values removed.
  *
  * @example

package/dist/array/compact.d.ts

@@ -3,7 +3,7 @@ type NotFalsey<T> = Exclude<T, false | null | 0 | '' | undefined>;
  * Removes falsey values (false, null, 0, '', undefined, NaN) from an array.
  *
  * @template T - The type of elements in the array.
- * @param {readonly T[]} arr - The input array to remove falsey values.
+ * @param {T[]} arr - The input array to remove falsey values.
  * @returns {Array<Exclude<T, false | null | 0 | '' | undefined>>} - A new array with all falsey values removed.
  *
  * @example

package/dist/array/compact.mjs

@@ -1,8 +1,11 @@
-import {
-  compact
-} from "../chunk-DTJJIMKJ.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  compact
-};
-//# sourceMappingURL=compact.mjs.map
+function compact(arr) {
+    const result = [];
+    for (const item of arr) {
+        if (item) {
+            result.push(item);
+        }
+    }
+    return result;
+}
+
+export { compact };

package/dist/array/countBy.mjs

@@ -1,8 +1,10 @@
-import {
-  countBy
-} from "../chunk-CRSKT4WW.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  countBy
-};
-//# sourceMappingURL=countBy.mjs.map
+function countBy(arr, mapper) {
+    const result = {};
+    for (const item of arr) {
+        const key = mapper(item);
+        result[key] = (result[key] ?? 0) + 1;
+    }
+    return result;
+}
+
+export { countBy };

package/dist/array/difference.mjs

@@ -1,8 +1,6 @@
-import {
-  difference
-} from "../chunk-JPUKH67K.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  difference
-};
-//# sourceMappingURL=difference.mjs.map
+function difference(firstArr, secondArr) {
+    const secondSet = new Set(secondArr);
+    return firstArr.filter(item => !secondSet.has(item));
+}
+
+export { difference };

package/dist/array/differenceBy.mjs

@@ -1,8 +1,8 @@
-import {
-  differenceBy
-} from "../chunk-LVWX5B43.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  differenceBy
-};
-//# sourceMappingURL=differenceBy.mjs.map
+function differenceBy(firstArr, secondArr, mapper) {
+    const mappedSecondSet = new Set(secondArr.map(item => mapper(item)));
+    return firstArr.filter(item => {
+        return !mappedSecondSet.has(mapper(item));
+    });
+}
+
+export { differenceBy };

package/dist/array/differenceWith.mjs

@@ -1,8 +1,9 @@
-import {
-  differenceWith
-} from "../chunk-6NVQAHXP.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  differenceWith
-};
-//# sourceMappingURL=differenceWith.mjs.map
+function differenceWith(firstArr, secondArr, areItemsEqual) {
+    return firstArr.filter(firstItem => {
+        return secondArr.every(secondItem => {
+            return !areItemsEqual(firstItem, secondItem);
+        });
+    });
+}
+
+export { differenceWith };

package/dist/array/drop.mjs

@@ -1,8 +1,6 @@
-import {
-  drop
-} from "../chunk-3EZAFZG3.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  drop
-};
-//# sourceMappingURL=drop.mjs.map
+function drop(arr, itemsCount) {
+    itemsCount = Math.max(itemsCount, 0);
+    return arr.slice(itemsCount);
+}
+
+export { drop };

package/dist/array/dropRight.mjs

@@ -1,8 +1,9 @@
-import {
-  dropRight
-} from "../chunk-OXZCMC5I.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  dropRight
-};
-//# sourceMappingURL=dropRight.mjs.map
+function dropRight(arr, itemsCount) {
+    itemsCount = Math.min(-itemsCount, 0);
+    if (itemsCount === 0) {
+        return arr.slice();
+    }
+    return arr.slice(0, itemsCount);
+}
+
+export { dropRight };

package/dist/array/dropRightWhile.mjs

@@ -1,8 +1,10 @@
-import {
-  dropRightWhile
-} from "../chunk-M7SBBYV2.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  dropRightWhile
-};
-//# sourceMappingURL=dropRightWhile.mjs.map
+function dropRightWhile(arr, canContinueDropping) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (!canContinueDropping(arr[i])) {
+            return arr.slice(0, i + 1);
+        }
+    }
+    return [];
+}
+
+export { dropRightWhile };

package/dist/array/dropWhile.mjs

@@ -1,8 +1,9 @@
-import {
-  dropWhile
-} from "../chunk-LJ2C6MVP.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  dropWhile
-};
-//# sourceMappingURL=dropWhile.mjs.map
+function dropWhile(arr, canContinueDropping) {
+    const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));
+    if (dropEndIndex === -1) {
+        return [];
+    }
+    return arr.slice(dropEndIndex);
+}
+
+export { dropWhile };

package/dist/array/fill.d.mts

@@ -5,6 +5,7 @@
  * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
  * entire array.
  *
+ * @template T, U
  * @param {Array<T | U>} array - The array to fill.
  * @param {U} value - The value to fill the array with.
  * @param {number} [start=0] - The start position. Defaults to 0.

package/dist/array/fill.d.ts

@@ -5,6 +5,7 @@
  * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
  * entire array.
  *
+ * @template T, U
  * @param {Array<T | U>} array - The array to fill.
  * @param {U} value - The value to fill the array with.
  * @param {number} [start=0] - The start position. Defaults to 0.

package/dist/array/fill.mjs

@@ -1,8 +1,11 @@
-import {
-  fill
-} from "../chunk-YFN6KOC4.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  fill
-};
-//# sourceMappingURL=fill.mjs.map
+function fill(array, value, start = 0, end = array.length) {
+    const length = array.length;
+    const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+    const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+    for (let i = finalStart; i < finalEnd; i++) {
+        array[i] = value;
+    }
+    return array;
+}
+
+export { fill };

package/dist/array/flatMap.mjs

@@ -1,9 +1,7 @@
-import {
-  flatMap
-} from "../chunk-UY76KTPE.mjs";
-import "../chunk-33MSBDC6.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  flatMap
-};
-//# sourceMappingURL=flatMap.mjs.map
+import { flatten } from './flatten.mjs';
+
+function flatMap(arr, iteratee, depth = 1) {
+    return flatten(arr.map(item => iteratee(item)), depth);
+}
+
+export { flatMap };

package/dist/array/flatten.mjs

@@ -1,8 +1,18 @@
-import {
-  flatten
-} from "../chunk-33MSBDC6.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  flatten
-};
-//# sourceMappingURL=flatten.mjs.map
+function flatten(arr, depth = 1) {
+    const result = [];
+    const flooredDepth = Math.floor(depth);
+    const recursive = (arr, currentDepth) => {
+        for (const item of arr) {
+            if (Array.isArray(item) && currentDepth < flooredDepth) {
+                recursive(item, currentDepth + 1);
+            }
+            else {
+                result.push(item);
+            }
+        }
+    };
+    recursive(arr, 0);
+    return result;
+}
+
+export { flatten };

package/dist/array/flattenDeep.mjs

@@ -1,9 +1,7 @@
-import {
-  flattenDeep
-} from "../chunk-ML727RRJ.mjs";
-import "../chunk-33MSBDC6.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  flattenDeep
-};
-//# sourceMappingURL=flattenDeep.mjs.map
+import { flatten } from './flatten.mjs';
+
+function flattenDeep(arr) {
+    return flatten(arr, Infinity);
+}
+
+export { flattenDeep };

package/dist/array/forEachRight.mjs

@@ -1,8 +1,8 @@
-import {
-  forEachRight
-} from "../chunk-IEA53J7P.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  forEachRight
-};
-//# sourceMappingURL=forEachRight.mjs.map
+function forEachRight(arr, callback) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        const element = arr[i];
+        callback(element, i, arr);
+    }
+}
+
+export { forEachRight };

package/dist/array/groupBy.mjs

@@ -1,8 +1,13 @@
-import {
-  groupBy
-} from "../chunk-E6E4RZLN.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  groupBy
-};
-//# sourceMappingURL=groupBy.mjs.map
+function groupBy(arr, getKeyFromItem) {
+    const result = {};
+    for (const item of arr) {
+        const key = getKeyFromItem(item);
+        if (result[key] == null) {
+            result[key] = [];
+        }
+        result[key].push(item);
+    }
+    return result;
+}
+
+export { groupBy };