es-toolkit 1.26.1 → 1.27.0-dev.874

package/dist/compat/_internal/flattenArrayLike.mjs

@@ -0,0 +1,17 @@
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function flattenArrayLike(values) {
+    const result = [];
+    for (let i = 0; i < values.length; i++) {
+        const arrayLike = values[i];
+        if (!isArrayLikeObject(arrayLike)) {
+            continue;
+        }
+        for (let j = 0; j < arrayLike.length; j++) {
+            result.push(arrayLike[j]);
+        }
+    }
+    return result;
+}
+
+export { flattenArrayLike };

package/dist/compat/_internal/isPrototype.mjs

@@ -0,0 +1,7 @@
+function isPrototype(value) {
+    const constructor = value.constructor;
+    const prototype = typeof constructor === 'function' ? constructor.prototype : Object.prototype;
+    return value === prototype;
+}
+
+export { isPrototype };

package/dist/compat/_internal/toArray.mjs

@@ -0,0 +1,5 @@
+function toArray(value) {
+    return Array.isArray(value) ? value : Array.from(value);
+}
+
+export { toArray };

package/dist/compat/array/chunk.mjs

@@ -1,4 +1,5 @@
 import { chunk as chunk$1 } from '../../array/chunk.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 
 function chunk(arr, size = 1) {
@@ -6,7 +7,7 @@ function chunk(arr, size = 1) {
     if (size === 0 || !isArrayLike(arr)) {
         return [];
     }
-    return chunk$1(Array.from(arr), size);
+    return chunk$1(toArray(arr), size);
 }
 
 export { chunk };

package/dist/compat/array/difference.mjs

@@ -1,11 +1,12 @@
 import { difference as difference$1 } from '../../array/difference.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
 
 function difference(arr, ...values) {
     if (!isArrayLikeObject(arr)) {
         return [];
     }
-    const arr1 = Array.from(arr);
+    const arr1 = toArray(arr);
     const arr2 = [];
     for (let i = 0; i < values.length; i++) {
         const value = values[i];

package/dist/compat/array/differenceBy.d.mts

@@ -0,0 +1,82 @@
+type Iteratee<T> = PropertyKey | Partial<T> | ((value: T) => unknown);
+/**
+ * Computes the difference between an array and another array using an iteratee function.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {ArrayLike<T2>} values - The array containing elements to be excluded from the primary array.
+ * @param {Iteratee<T1 | T2>} iteratee - The iteratee invoked per element.
+ * @returns {T1[]} A new array containing the elements that are present in the primary array but not in the values array.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+ * // result will be [1.2]
+ *
+ * @example
+ * const result = differenceBy([{ x: 2 }, { x: 1 }], [{ x: 1 }], 'x');
+ * // result will be [{ x: 2 }]
+ */
+declare function differenceBy<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, iteratee: Iteratee<T1 | T2>): T1[];
+/**
+ * Computes the difference between an array and two other arrays using an iteratee function.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to be excluded from the primary array.
+ * @param {Iteratee<T1 | T2 | T3>} iteratee - The iteratee invoked per element.
+ * @returns {T1[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], [1.2], Math.floor);
+ * // result will be []
+ */
+declare function differenceBy<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, iteratee: Iteratee<T1 | T2 | T3>): T1[];
+/**
+ * Computes the difference between an array and three other arrays using an iteratee function.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T4>} values3 - The third array containing elements to be excluded from the primary array.
+ * @param {Iteratee<T1 | T2 | T3 | T4>} iteratee - The iteratee invoked per element.
+ * @returns {T1[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], [1.2], [2.1], Math.floor);
+ * // result will be []
+ */
+declare function differenceBy<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, values3: ArrayLike<T4>, iteratee: Iteratee<T1 | T2 | T3 | T4>): T1[];
+/**
+ * Computes the difference between an array and four other arrays using an iteratee function.
+ *
+ * @template T1, T2, T3, T4, T5
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T4>} values3 - The third array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T5>} values4 - The fourth array containing elements to be excluded from the primary array.
+ * @param {Iteratee<T1 | T2 | T3 | T4 | T5>} iteratee - The iteratee invoked per element.
+ * @returns {T1[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], [1.2], [2.1], [3.4], Math.floor);
+ * // result will be []
+ */
+declare function differenceBy<T1, T2, T3, T4, T5>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, values3: ArrayLike<T4>, values4: ArrayLike<T5>, iteratee: Iteratee<T1 | T2 | T3 | T4 | T5>): T1[];
+/**
+ * Computes the difference between an array and multiple arrays using an iteratee function.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {...Array<ArrayLike<T>>} values - Multiple arrays containing elements to be excluded from the primary array.
+ * @returns {T[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], [1.2], [2.1], [3.4], Math.floor);
+ * // result will be []
+ */
+declare function differenceBy<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T>>): T[];
+
+export { differenceBy };

package/dist/compat/array/differenceBy.d.ts

@@ -0,0 +1,82 @@
+type Iteratee<T> = PropertyKey | Partial<T> | ((value: T) => unknown);
+/**
+ * Computes the difference between an array and another array using an iteratee function.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {ArrayLike<T2>} values - The array containing elements to be excluded from the primary array.
+ * @param {Iteratee<T1 | T2>} iteratee - The iteratee invoked per element.
+ * @returns {T1[]} A new array containing the elements that are present in the primary array but not in the values array.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+ * // result will be [1.2]
+ *
+ * @example
+ * const result = differenceBy([{ x: 2 }, { x: 1 }], [{ x: 1 }], 'x');
+ * // result will be [{ x: 2 }]
+ */
+declare function differenceBy<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, iteratee: Iteratee<T1 | T2>): T1[];
+/**
+ * Computes the difference between an array and two other arrays using an iteratee function.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to be excluded from the primary array.
+ * @param {Iteratee<T1 | T2 | T3>} iteratee - The iteratee invoked per element.
+ * @returns {T1[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], [1.2], Math.floor);
+ * // result will be []
+ */
+declare function differenceBy<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, iteratee: Iteratee<T1 | T2 | T3>): T1[];
+/**
+ * Computes the difference between an array and three other arrays using an iteratee function.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T4>} values3 - The third array containing elements to be excluded from the primary array.
+ * @param {Iteratee<T1 | T2 | T3 | T4>} iteratee - The iteratee invoked per element.
+ * @returns {T1[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], [1.2], [2.1], Math.floor);
+ * // result will be []
+ */
+declare function differenceBy<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, values3: ArrayLike<T4>, iteratee: Iteratee<T1 | T2 | T3 | T4>): T1[];
+/**
+ * Computes the difference between an array and four other arrays using an iteratee function.
+ *
+ * @template T1, T2, T3, T4, T5
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T4>} values3 - The third array containing elements to be excluded from the primary array.
+ * @param {ArrayLike<T5>} values4 - The fourth array containing elements to be excluded from the primary array.
+ * @param {Iteratee<T1 | T2 | T3 | T4 | T5>} iteratee - The iteratee invoked per element.
+ * @returns {T1[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], [1.2], [2.1], [3.4], Math.floor);
+ * // result will be []
+ */
+declare function differenceBy<T1, T2, T3, T4, T5>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, values3: ArrayLike<T4>, values4: ArrayLike<T5>, iteratee: Iteratee<T1 | T2 | T3 | T4 | T5>): T1[];
+/**
+ * Computes the difference between an array and multiple arrays using an iteratee function.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The primary array from which to derive the difference.
+ * @param {...Array<ArrayLike<T>>} values - Multiple arrays containing elements to be excluded from the primary array.
+ * @returns {T[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+ *
+ * @example
+ * const result = differenceBy([2.1, 1.2], [2.3, 3.4], [1.2], [2.1], [3.4], Math.floor);
+ * // result will be []
+ */
+declare function differenceBy<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T>>): T[];
+
+export { differenceBy };

package/dist/compat/array/differenceBy.mjs

@@ -0,0 +1,20 @@
+import { last } from './last.mjs';
+import { difference } from '../../array/difference.mjs';
+import { differenceBy as differenceBy$1 } from '../../array/differenceBy.mjs';
+import { flattenArrayLike } from '../_internal/flattenArrayLike.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function differenceBy(arr, ..._values) {
+    if (!isArrayLikeObject(arr)) {
+        return [];
+    }
+    const iteratee$1 = last(_values);
+    const values = flattenArrayLike(_values);
+    if (isArrayLikeObject(iteratee$1)) {
+        return difference(Array.from(arr), values);
+    }
+    return differenceBy$1(Array.from(arr), values, iteratee(iteratee$1));
+}
+
+export { differenceBy };

package/dist/compat/array/drop.mjs

@@ -1,4 +1,5 @@
 import { drop as drop$1 } from '../../array/drop.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { toInteger } from '../util/toInteger.mjs';
 
@@ -7,7 +8,7 @@ function drop(collection, itemsCount = 1, guard) {
         return [];
     }
     itemsCount = guard ? 1 : toInteger(itemsCount);
-    return drop$1(Array.from(collection), itemsCount);
+    return drop$1(toArray(collection), itemsCount);
 }
 
 export { drop };

package/dist/compat/array/dropRight.mjs

@@ -1,4 +1,5 @@
 import { dropRight as dropRight$1 } from '../../array/dropRight.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { toInteger } from '../util/toInteger.mjs';
 
@@ -7,7 +8,7 @@ function dropRight(collection, itemsCount = 1, guard) {
         return [];
     }
     itemsCount = guard ? 1 : toInteger(itemsCount);
-    return dropRight$1(Array.from(collection), itemsCount);
+    return dropRight$1(toArray(collection), itemsCount);
 }
 
 export { dropRight };

package/dist/compat/array/dropWhile.mjs

@@ -1,4 +1,5 @@
 import { dropWhile as dropWhile$1 } from '../../array/dropWhile.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { property } from '../object/property.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { matches } from '../predicate/matches.mjs';
@@ -8,7 +9,7 @@ function dropWhile(arr, predicate) {
     if (!isArrayLike(arr)) {
         return [];
     }
-    return dropWhileImpl(Array.from(arr), predicate);
+    return dropWhileImpl(toArray(arr), predicate);
 }
 function dropWhileImpl(arr, predicate) {
     switch (typeof predicate) {

package/dist/compat/array/findLastIndex.mjs

@@ -1,3 +1,4 @@
+import { toArray } from '../_internal/toArray.mjs';
 import { property } from '../object/property.mjs';
 import { matches } from '../predicate/matches.mjs';
 import { matchesProperty } from '../predicate/matchesProperty.mjs';
@@ -12,7 +13,7 @@ function findLastIndex(arr, doesMatch, fromIndex = arr ? arr.length - 1 : 0) {
     else {
         fromIndex = Math.min(fromIndex, arr.length - 1);
     }
-    const subArray = Array.from(arr).slice(0, fromIndex + 1);
+    const subArray = toArray(arr).slice(0, fromIndex + 1);
     switch (typeof doesMatch) {
         case 'function': {
             return subArray.findLastIndex(doesMatch);

package/dist/compat/array/forEach.d.mts

@@ -0,0 +1,106 @@
+/**
+ * Iterates over each element of the array invoking the provided callback function for each element.
+ *
+ * @template K - The type of elements in the array.
+ * @template T - The type of the array.
+ * @param {T | null | undefined} array - The array to iterate over.
+ * @param {(value: K, index: number, array: T) => unknown} [callback] - The function invoked for each element.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'array': The array 'forEach' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEach([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 1 0
+ * // 2 1
+ * // 3 2
+ *
+ */
+declare function forEach<T>(array: T[], callback?: (value: T, index: number, array: T[]) => unknown): T[];
+/**
+ * Iterates over each element of the array invoking the provided callback function for each element.
+ *
+ * @template K - The type of elements in the array.
+ * @template T - The type of the array.
+ * @param {T | null | undefined} array - The array to iterate over.
+ * @param {(value: K, index: number, array: T) => unknown} [callback] - The function invoked for each element.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'array': The array 'forEach' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEach([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 1 0
+ * // 2 1
+ * // 3 2
+ *
+ */
+declare function forEach<T>(array: readonly T[], callback?: (value: T, index: number, array: T[]) => unknown): readonly T[];
+/**
+ * Iterates over each element of the array invoking the provided callback function for each element.
+ *
+ * @template T - The type of string.
+ * @param {T | null | undefined} string - The string to iterate over
+ * @param {(value: T, index: number, string: T) => unknown} [callback] - The function invoked for each char.
+ * The callback function receives three arguments:
+ *  - 'char': The current char being processed in the string.
+ *  - 'index': The index of the current char being processed in the string.
+ *  - 'string': The string 'forEach' was called upon.
+ * @returns {T} Returns the original string.
+ *
+ * @example
+ * forEach('abc', (char, index, string) => console.log(char, index));
+ * // Output:
+ * // 'a' 0
+ * // 'b' 1
+ * // 'c' 2
+ */
+declare function forEach<T extends string | null | undefined>(string: T, callback?: (char: string, index: number, string: string) => unknown): T;
+/**
+ * Iterates over each element of the array invoking the provided callback function for each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param { ArrayLike<T> } array - The array to iterate over.
+ * @param {(value: T, index: number, array: ArrayLike<T>) => unknown} [callback] - The function invoked for each element.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'array': The array 'forEach' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEach([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 1 0
+ * // 2 1
+ * // 3 2
+ *
+ */
+declare function forEach<T>(array: ArrayLike<T>, callback?: (value: T, index: number, array: ArrayLike<T>) => unknown): ArrayLike<T>;
+/**
+ * Iterates over each element of the object invoking the provided callback function for each property.
+ *
+ * @template T - The type of object.
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} [callback] - The function invoked for each property.
+ * The callback function receives three arguments:
+ *  - 'value': The current property being processed in the object.
+ *  - 'key': The key of the current property being processed in the object.
+ *  - 'object': The object 'forEach' was called upon.
+ * @returns {T} Returns the original object.
+ *
+ * @example
+ * forEach({'a': 1, 'b': 2 }, (value, key, object) => console.log(value, key));
+ * // Output:
+ * // 1 'a'
+ * // 2 'b'
+ */
+declare function forEach<T extends object | null | undefined>(object: T, callback?: (value: T[keyof T], key: keyof T, object: T) => unknown): T;
+
+export { forEach };

package/dist/compat/array/forEach.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Iterates over each element of the array invoking the provided callback function for each element.
+ *
+ * @template K - The type of elements in the array.
+ * @template T - The type of the array.
+ * @param {T | null | undefined} array - The array to iterate over.
+ * @param {(value: K, index: number, array: T) => unknown} [callback] - The function invoked for each element.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'array': The array 'forEach' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEach([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 1 0
+ * // 2 1
+ * // 3 2
+ *
+ */
+declare function forEach<T>(array: T[], callback?: (value: T, index: number, array: T[]) => unknown): T[];
+/**
+ * Iterates over each element of the array invoking the provided callback function for each element.
+ *
+ * @template K - The type of elements in the array.
+ * @template T - The type of the array.
+ * @param {T | null | undefined} array - The array to iterate over.
+ * @param {(value: K, index: number, array: T) => unknown} [callback] - The function invoked for each element.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'array': The array 'forEach' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEach([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 1 0
+ * // 2 1
+ * // 3 2
+ *
+ */
+declare function forEach<T>(array: readonly T[], callback?: (value: T, index: number, array: T[]) => unknown): readonly T[];
+/**
+ * Iterates over each element of the array invoking the provided callback function for each element.
+ *
+ * @template T - The type of string.
+ * @param {T | null | undefined} string - The string to iterate over
+ * @param {(value: T, index: number, string: T) => unknown} [callback] - The function invoked for each char.
+ * The callback function receives three arguments:
+ *  - 'char': The current char being processed in the string.
+ *  - 'index': The index of the current char being processed in the string.
+ *  - 'string': The string 'forEach' was called upon.
+ * @returns {T} Returns the original string.
+ *
+ * @example
+ * forEach('abc', (char, index, string) => console.log(char, index));
+ * // Output:
+ * // 'a' 0
+ * // 'b' 1
+ * // 'c' 2
+ */
+declare function forEach<T extends string | null | undefined>(string: T, callback?: (char: string, index: number, string: string) => unknown): T;
+/**
+ * Iterates over each element of the array invoking the provided callback function for each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param { ArrayLike<T> } array - The array to iterate over.
+ * @param {(value: T, index: number, array: ArrayLike<T>) => unknown} [callback] - The function invoked for each element.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'array': The array 'forEach' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEach([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 1 0
+ * // 2 1
+ * // 3 2
+ *
+ */
+declare function forEach<T>(array: ArrayLike<T>, callback?: (value: T, index: number, array: ArrayLike<T>) => unknown): ArrayLike<T>;
+/**
+ * Iterates over each element of the object invoking the provided callback function for each property.
+ *
+ * @template T - The type of object.
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} [callback] - The function invoked for each property.
+ * The callback function receives three arguments:
+ *  - 'value': The current property being processed in the object.
+ *  - 'key': The key of the current property being processed in the object.
+ *  - 'object': The object 'forEach' was called upon.
+ * @returns {T} Returns the original object.
+ *
+ * @example
+ * forEach({'a': 1, 'b': 2 }, (value, key, object) => console.log(value, key));
+ * // Output:
+ * // 1 'a'
+ * // 2 'b'
+ */
+declare function forEach<T extends object | null | undefined>(object: T, callback?: (value: T[keyof T], key: keyof T, object: T) => unknown): T;
+
+export { forEach };

package/dist/compat/array/forEach.mjs

@@ -0,0 +1,21 @@
+import { identity } from '../../function/identity.mjs';
+import { range } from '../../math/range.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function forEach(collection, callback = identity) {
+    if (!collection) {
+        return collection;
+    }
+    const keys = isArrayLike(collection) || Array.isArray(collection) ? range(0, collection.length) : Object.keys(collection);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = collection[key];
+        const result = callback(value, key, collection);
+        if (result === false) {
+            break;
+        }
+    }
+    return collection;
+}
+
+export { forEach };

package/dist/compat/array/head.mjs

@@ -1,11 +1,12 @@
 import { head as head$1 } from '../../array/head.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 
 function head(arr) {
     if (!isArrayLike(arr)) {
         return undefined;
     }
-    return head$1(Array.from(arr));
+    return head$1(toArray(arr));
 }
 
 export { head };

package/dist/compat/array/last.mjs

@@ -1,11 +1,12 @@
 import { last as last$1 } from '../../array/last.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 
 function last(array) {
     if (!isArrayLike(array)) {
         return undefined;
     }
-    return last$1(Array.from(array));
+    return last$1(toArray(array));
 }
 
 export { last };

package/dist/compat/array/sample.mjs

@@ -1,4 +1,5 @@
 import { sample as sample$1 } from '../../array/sample.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 
 function sample(collection) {
@@ -6,7 +7,7 @@ function sample(collection) {
         return undefined;
     }
     if (isArrayLike(collection)) {
-        return sample$1(Array.from(collection));
+        return sample$1(toArray(collection));
     }
     return sample$1(Object.values(collection));
 }

package/dist/compat/array/tail.mjs

@@ -1,11 +1,12 @@
 import { tail as tail$1 } from '../../array/tail.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 
 function tail(arr) {
     if (!isArrayLike(arr)) {
         return [];
     }
-    return tail$1(Array.from(arr));
+    return tail$1(toArray(arr));
 }
 
 export { tail };

package/dist/compat/array/take.mjs

@@ -1,4 +1,5 @@
 import { take as take$1 } from '../../array/take.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { toInteger } from '../util/toInteger.mjs';
 
@@ -7,7 +8,7 @@ function take(arr, count = 1, guard) {
     if (count < 1 || !isArrayLike(arr)) {
         return [];
     }
-    return take$1(Array.from(arr), count);
+    return take$1(toArray(arr), count);
 }
 
 export { take };

package/dist/compat/array/takeRight.mjs

@@ -1,4 +1,5 @@
 import { takeRight as takeRight$1 } from '../../array/takeRight.mjs';
+import { toArray } from '../_internal/toArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { toInteger } from '../util/toInteger.mjs';
 
@@ -7,7 +8,7 @@ function takeRight(arr, count = 1, guard) {
     if (count <= 0 || !isArrayLike(arr)) {
         return [];
     }
-    return takeRight$1(Array.from(arr), count);
+    return takeRight$1(toArray(arr), count);
 }
 
 export { takeRight };