es-toolkit 1.24.0 → 1.25.0-dev.786

package/dist/compat/_internal/MAX_SAFE_INTEGER.mjs

@@ -0,0 +1,3 @@
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+
+export { MAX_SAFE_INTEGER };

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

@@ -6,10 +6,9 @@
  * the final sub-array will contain the remaining elements.
  *
  * @template T The type of elements in the array.
- * @param {T[]} arr - The array to be chunked into smaller arrays.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to be chunked into smaller arrays.
  * @param {number} size - The size of each smaller array. Must be a positive integer.
  * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.
- * @throws {Error} Throws an error if `size` is not a positive integer.
  *
  * @example
  * // Splits an array of numbers into sub-arrays of length 2
@@ -21,6 +20,6 @@
  * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
  * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
  */
-declare function chunk<T>(arr: readonly T[], size?: number): T[][];
+declare function chunk<T>(arr: ArrayLike<T> | null | undefined, size?: number): T[][];
 
 export { chunk };

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

@@ -6,10 +6,9 @@
  * the final sub-array will contain the remaining elements.
  *
  * @template T The type of elements in the array.
- * @param {T[]} arr - The array to be chunked into smaller arrays.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to be chunked into smaller arrays.
  * @param {number} size - The size of each smaller array. Must be a positive integer.
  * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.
- * @throws {Error} Throws an error if `size` is not a positive integer.
  *
  * @example
  * // Splits an array of numbers into sub-arrays of length 2
@@ -21,6 +20,6 @@
  * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
  * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
  */
-declare function chunk<T>(arr: readonly T[], size?: number): T[][];
+declare function chunk<T>(arr: ArrayLike<T> | null | undefined, size?: number): T[][];
 
 export { chunk };

package/dist/compat/array/chunk.mjs

@@ -1,11 +1,12 @@
 import { chunk as chunk$1 } from '../../array/chunk.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
 
 function chunk(arr, size = 1) {
     size = Math.max(Math.floor(size), 0);
-    if (size === 0) {
+    if (size === 0 || !isArrayLike(arr)) {
         return [];
     }
-    return chunk$1(arr, size);
+    return chunk$1(Array.from(arr), size);
 }
 
 export { chunk };

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

@@ -0,0 +1,16 @@
+type Falsey = false | null | 0 | 0n | '' | undefined;
+type NotFalsey<T> = Exclude<T, Falsey>;
+/**
+ * Removes falsey values (false, null, 0, 0n, '', undefined, NaN) from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T | Falsey> | null | undefined} arr - The input array to remove falsey values.
+ * @returns {Array<Exclude<T, false | null | 0 | 0n | '' | undefined>>} - A new array with all falsey values removed.
+ *
+ * @example
+ * compact([0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+ * Returns: [1, 2, 3, 4, 5]
+ */
+declare function compact<T>(arr: ArrayLike<T | Falsey> | null | undefined): Array<NotFalsey<T>>;
+
+export { compact };

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

@@ -0,0 +1,16 @@
+type Falsey = false | null | 0 | 0n | '' | undefined;
+type NotFalsey<T> = Exclude<T, Falsey>;
+/**
+ * Removes falsey values (false, null, 0, 0n, '', undefined, NaN) from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T | Falsey> | null | undefined} arr - The input array to remove falsey values.
+ * @returns {Array<Exclude<T, false | null | 0 | 0n | '' | undefined>>} - A new array with all falsey values removed.
+ *
+ * @example
+ * compact([0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+ * Returns: [1, 2, 3, 4, 5]
+ */
+declare function compact<T>(arr: ArrayLike<T | Falsey> | null | undefined): Array<NotFalsey<T>>;
+
+export { compact };

package/dist/compat/array/compact.mjs

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

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

@@ -5,7 +5,7 @@
  * of elements removed from the start.
  *
  * @template T - The type of elements in the array.
- * @param { T[] |  null | undefined} collection - - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
  * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
  * @returns {T[]} A new array with the specified number of elements removed from the start.
  *
@@ -14,6 +14,6 @@
  * const result = drop(array, 2);
  * result will be [3, 4, 5] since the first two elements are dropped.
  */
-declare function drop<T>(collection: readonly T[] | null | undefined, itemsCount: number): T[];
+declare function drop<T>(collection: ArrayLike<T> | null | undefined, itemsCount: number): T[];
 
 export { drop };

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

@@ -5,7 +5,7 @@
  * of elements removed from the start.
  *
  * @template T - The type of elements in the array.
- * @param { T[] |  null | undefined} collection - - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
  * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
  * @returns {T[]} A new array with the specified number of elements removed from the start.
  *
@@ -14,6 +14,6 @@
  * const result = drop(array, 2);
  * result will be [3, 4, 5] since the first two elements are dropped.
  */
-declare function drop<T>(collection: readonly T[] | null | undefined, itemsCount: number): T[];
+declare function drop<T>(collection: ArrayLike<T> | null | undefined, itemsCount: number): T[];
 
 export { drop };

package/dist/compat/array/drop.mjs

@@ -1,9 +1,11 @@
+import { drop as drop$1 } from '../../array/drop.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
 function drop(collection, itemsCount) {
-    if (collection === null || collection === undefined) {
+    if (!isArrayLike(collection)) {
         return [];
     }
-    itemsCount = Math.max(itemsCount, 0);
-    return collection.slice(itemsCount);
+    return drop$1(Array.from(collection), itemsCount);
 }
 
 export { drop };

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

@@ -0,0 +1,19 @@
+/**
+ * Removes a specified number of elements from the end of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the end.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
+ * @param {number} itemsCount - The number of elements to drop from the end of the array.
+ * @returns {T[]} A new array with the specified number of elements removed from the end.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = dropRight(array, 2);
+ * // result will be [1, 2, 3] since the last two elements are dropped.
+ */
+declare function dropRight<T>(collection: ArrayLike<T> | null | undefined, itemsCount: number): T[];
+
+export { dropRight };

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

@@ -0,0 +1,19 @@
+/**
+ * Removes a specified number of elements from the end of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the end.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
+ * @param {number} itemsCount - The number of elements to drop from the end of the array.
+ * @returns {T[]} A new array with the specified number of elements removed from the end.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = dropRight(array, 2);
+ * // result will be [1, 2, 3] since the last two elements are dropped.
+ */
+declare function dropRight<T>(collection: ArrayLike<T> | null | undefined, itemsCount: number): T[];
+
+export { dropRight };

package/dist/compat/array/dropRight.mjs

@@ -0,0 +1,11 @@
+import { dropRight as dropRight$1 } from '../../array/dropRight.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function dropRight(collection, itemsCount) {
+    if (!isArrayLike(collection)) {
+        return [];
+    }
+    return dropRight$1(Array.from(collection), itemsCount);
+}
+
+export { dropRight };

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

@@ -2,7 +2,7 @@
  * Drops elements from the end of an array while the predicate function returns truthy.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {(item: T, index: number, arr: T[]) => unknown} canContinueDropping - A predicate function that determines
  * whether to continue dropping elements. The function is called with each element, index, and array, and dropping
  * continues as long as it returns true.
@@ -13,12 +13,12 @@
  * const result = dropRightWhile(array, x => x < 3);
  * result will be [5, 4, 3] since elements less than 3 are dropped.
  */
-declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+declare function dropRightWhile<T>(arr: ArrayLike<T> | null | undefined, canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
 /**
  * Drops elements from the end of an array while the specified object properties match.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {Partial<T>} objectToDrop - An object specifying the properties to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -27,12 +27,12 @@ declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item
  * const result = dropRightWhile(array, { a: 3 });
  * result will be [{ a: 1 }, { a: 2 }] since the last object matches the properties of the provided object.
  */
-declare function dropRightWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
+declare function dropRightWhile<T>(arr: ArrayLike<T> | null | undefined, objectToDrop: Partial<T>): T[];
 /**
  * Drops elements from the end of an array while the specified property matches a given value.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {[keyof T, unknown]} propertyToDrop - A tuple containing the property key and the value to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -41,12 +41,12 @@ declare function dropRightWhile<T>(arr: readonly T[], objectToDrop: Partial<T>):
  * const result = dropRightWhile(array, ['id', 3]);
  * result will be [{ id: 1 }, { id: 2 }] since the last object has the id property matching the value 3.
  */
-declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unknown]): T[];
+declare function dropRightWhile<T>(arr: ArrayLike<T> | null | undefined, propertyToDrop: [keyof T, unknown]): T[];
 /**
  * Drops elements from the end of an array while the specified property name matches.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {string} propertyToDrop - The name of the property to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -55,6 +55,6 @@ declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: [keyof T,
  * const result = dropRightWhile(array, 'isActive');
  * result will be [{ isActive: false }] since it drops elements until it finds one with a falsy isActive property.
  */
-declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: string): T[];
+declare function dropRightWhile<T>(arr: ArrayLike<T> | null | undefined, propertyToDrop: string): T[];
 
 export { dropRightWhile };

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

@@ -2,7 +2,7 @@
  * Drops elements from the end of an array while the predicate function returns truthy.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {(item: T, index: number, arr: T[]) => unknown} canContinueDropping - A predicate function that determines
  * whether to continue dropping elements. The function is called with each element, index, and array, and dropping
  * continues as long as it returns true.
@@ -13,12 +13,12 @@
  * const result = dropRightWhile(array, x => x < 3);
  * result will be [5, 4, 3] since elements less than 3 are dropped.
  */
-declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+declare function dropRightWhile<T>(arr: ArrayLike<T> | null | undefined, canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
 /**
  * Drops elements from the end of an array while the specified object properties match.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {Partial<T>} objectToDrop - An object specifying the properties to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -27,12 +27,12 @@ declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item
  * const result = dropRightWhile(array, { a: 3 });
  * result will be [{ a: 1 }, { a: 2 }] since the last object matches the properties of the provided object.
  */
-declare function dropRightWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
+declare function dropRightWhile<T>(arr: ArrayLike<T> | null | undefined, objectToDrop: Partial<T>): T[];
 /**
  * Drops elements from the end of an array while the specified property matches a given value.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {[keyof T, unknown]} propertyToDrop - A tuple containing the property key and the value to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -41,12 +41,12 @@ declare function dropRightWhile<T>(arr: readonly T[], objectToDrop: Partial<T>):
  * const result = dropRightWhile(array, ['id', 3]);
  * result will be [{ id: 1 }, { id: 2 }] since the last object has the id property matching the value 3.
  */
-declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unknown]): T[];
+declare function dropRightWhile<T>(arr: ArrayLike<T> | null | undefined, propertyToDrop: [keyof T, unknown]): T[];
 /**
  * Drops elements from the end of an array while the specified property name matches.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {string} propertyToDrop - The name of the property to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -55,6 +55,6 @@ declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: [keyof T,
  * const result = dropRightWhile(array, 'isActive');
  * result will be [{ isActive: false }] since it drops elements until it finds one with a falsy isActive property.
  */
-declare function dropRightWhile<T>(arr: readonly T[], propertyToDrop: string): T[];
+declare function dropRightWhile<T>(arr: ArrayLike<T> | null | undefined, propertyToDrop: string): T[];
 
 export { dropRightWhile };

package/dist/compat/array/dropRightWhile.mjs

@@ -1,9 +1,16 @@
 import { dropRightWhile as dropRightWhile$1 } from '../../array/dropRightWhile.mjs';
 import { property } from '../object/property.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { matches } from '../predicate/matches.mjs';
 import { matchesProperty } from '../predicate/matchesProperty.mjs';
 
 function dropRightWhile(arr, predicate) {
+    if (!isArrayLike(arr)) {
+        return [];
+    }
+    return dropRightWhileImpl(Array.from(arr), predicate);
+}
+function dropRightWhileImpl(arr, predicate) {
     switch (typeof predicate) {
         case 'function': {
             return dropRightWhile$1(arr, (item, index, arr) => Boolean(predicate(item, index, arr)));

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

@@ -2,7 +2,7 @@
  * Drops elements from the beginning of an array while the predicate function returns truthy.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {(item: T, index: number, arr: T[]) => unknown} canContinueDropping - A predicate function that determines
  * whether to continue dropping elements. The function is called with each element, index, and array, and dropping
  * continues as long as it returns true.
@@ -13,12 +13,12 @@
  * const result = dropWhile(array, x => x < 3);
  * result will be [3, 4, 5] since elements less than 3 are dropped.
  */
-declare function dropWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+declare function dropWhile<T>(arr: ArrayLike<T> | null | undefined, canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
 /**
  * Drops elements from the beginning of an array while the specified object properties match.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {Partial<T>} objectToDrop - An object specifying the properties to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -27,12 +27,12 @@ declare function dropWhile<T>(arr: readonly T[], canContinueDropping: (item: T,
  * const result = dropWhile(array, { a: 1 });
  * result will be [{ a: 2 }, { a: 3 }] since the first object matches the properties of the provided object.
  */
-declare function dropWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
+declare function dropWhile<T>(arr: ArrayLike<T> | null | undefined, objectToDrop: Partial<T>): T[];
 /**
  * Drops elements from the beginning of an array while the specified property matches a given value.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {[keyof T, unknown]} propertyToDrop - A tuple containing the property key and the value to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -41,12 +41,12 @@ declare function dropWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
  * const result = dropWhile(array, ['id', 1]);
  * result will be [{ id: 2 }, { id: 3 }] since the first object has the id property matching the value 1.
  */
-declare function dropWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unknown]): T[];
+declare function dropWhile<T>(arr: ArrayLike<T> | null | undefined, propertyToDrop: [keyof T, unknown]): T[];
 /**
  * Drops elements from the beginning of an array while the specified property name matches.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {string} propertyToDrop - The name of the property to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -55,6 +55,6 @@ declare function dropWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unkno
  * const result = dropWhile(array, 'isActive');
  * result will be [{ isActive: false }] since it drops elements until it finds one with a falsy isActive property.
  */
-declare function dropWhile<T>(arr: readonly T[], propertyToDrop: string): T[];
+declare function dropWhile<T>(arr: ArrayLike<T> | null | undefined, propertyToDrop: string): T[];
 
 export { dropWhile };

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

@@ -2,7 +2,7 @@
  * Drops elements from the beginning of an array while the predicate function returns truthy.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {(item: T, index: number, arr: T[]) => unknown} canContinueDropping - A predicate function that determines
  * whether to continue dropping elements. The function is called with each element, index, and array, and dropping
  * continues as long as it returns true.
@@ -13,12 +13,12 @@
  * const result = dropWhile(array, x => x < 3);
  * result will be [3, 4, 5] since elements less than 3 are dropped.
  */
-declare function dropWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+declare function dropWhile<T>(arr: ArrayLike<T> | null | undefined, canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
 /**
  * Drops elements from the beginning of an array while the specified object properties match.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {Partial<T>} objectToDrop - An object specifying the properties to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -27,12 +27,12 @@ declare function dropWhile<T>(arr: readonly T[], canContinueDropping: (item: T,
  * const result = dropWhile(array, { a: 1 });
  * result will be [{ a: 2 }, { a: 3 }] since the first object matches the properties of the provided object.
  */
-declare function dropWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
+declare function dropWhile<T>(arr: ArrayLike<T> | null | undefined, objectToDrop: Partial<T>): T[];
 /**
  * Drops elements from the beginning of an array while the specified property matches a given value.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {[keyof T, unknown]} propertyToDrop - A tuple containing the property key and the value to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -41,12 +41,12 @@ declare function dropWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
  * const result = dropWhile(array, ['id', 1]);
  * result will be [{ id: 2 }, { id: 3 }] since the first object has the id property matching the value 1.
  */
-declare function dropWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unknown]): T[];
+declare function dropWhile<T>(arr: ArrayLike<T> | null | undefined, propertyToDrop: [keyof T, unknown]): T[];
 /**
  * Drops elements from the beginning of an array while the specified property name matches.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
  * @param {string} propertyToDrop - The name of the property to match for dropping elements.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -55,6 +55,6 @@ declare function dropWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unkno
  * const result = dropWhile(array, 'isActive');
  * result will be [{ isActive: false }] since it drops elements until it finds one with a falsy isActive property.
  */
-declare function dropWhile<T>(arr: readonly T[], propertyToDrop: string): T[];
+declare function dropWhile<T>(arr: ArrayLike<T> | null | undefined, propertyToDrop: string): T[];
 
 export { dropWhile };

package/dist/compat/array/dropWhile.mjs

@@ -1,9 +1,16 @@
 import { dropWhile as dropWhile$1 } from '../../array/dropWhile.mjs';
 import { property } from '../object/property.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { matches } from '../predicate/matches.mjs';
 import { matchesProperty } from '../predicate/matchesProperty.mjs';
 
 function dropWhile(arr, predicate) {
+    if (!isArrayLike(arr)) {
+        return [];
+    }
+    return dropWhileImpl(Array.from(arr), predicate);
+}
+function dropWhileImpl(arr, predicate) {
     switch (typeof predicate) {
         case 'function': {
             return dropWhile$1(arr, (item, index, arr) => Boolean(predicate(item, index, arr)));

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

@@ -0,0 +1,18 @@
+/**
+ * Returns the first element of an array or `undefined` if the array is empty.
+ *
+ * This function takes an array and returns the first element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | undefined | null} arr - The array from which to get the first element.
+ * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const emptyArr: number[] = [];
+ * const noElement = head(emptyArr);
+ * // noElement will be undefined
+ */
+declare function head<T>(arr: ArrayLike<T> | undefined | null): T | undefined;
+
+export { head };

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

@@ -0,0 +1,18 @@
+/**
+ * Returns the first element of an array or `undefined` if the array is empty.
+ *
+ * This function takes an array and returns the first element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | undefined | null} arr - The array from which to get the first element.
+ * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const emptyArr: number[] = [];
+ * const noElement = head(emptyArr);
+ * // noElement will be undefined
+ */
+declare function head<T>(arr: ArrayLike<T> | undefined | null): T | undefined;
+
+export { head };

package/dist/compat/array/head.mjs

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

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

@@ -0,0 +1,20 @@
+/**
+ * Returns the intersection of multiple arrays.
+ *
+ * This function takes multiple arrays and returns a new array containing the elements that are
+ * present in all provided arrays. It effectively filters out any elements that are not found
+ * in every array.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {...(ArrayLike<T> | null | undefined)} arrays - The arrays to compare.
+ * @returns {T[]} A new array containing the elements that are present in all arrays.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [3, 4, 5, 6, 7];
+ * const result = intersection(array1, array2);
+ * // result will be [3, 4, 5] since these elements are in both arrays.
+ */
+declare function intersection<T>(...arrays: Array<ArrayLike<T> | null | undefined>): T[];
+
+export { intersection };

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

@@ -0,0 +1,20 @@
+/**
+ * Returns the intersection of multiple arrays.
+ *
+ * This function takes multiple arrays and returns a new array containing the elements that are
+ * present in all provided arrays. It effectively filters out any elements that are not found
+ * in every array.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {...(ArrayLike<T> | null | undefined)} arrays - The arrays to compare.
+ * @returns {T[]} A new array containing the elements that are present in all arrays.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [3, 4, 5, 6, 7];
+ * const result = intersection(array1, array2);
+ * // result will be [3, 4, 5] since these elements are in both arrays.
+ */
+declare function intersection<T>(...arrays: Array<ArrayLike<T> | null | undefined>): T[];
+
+export { intersection };

package/dist/compat/array/intersection.mjs

@@ -0,0 +1,23 @@
+import { intersection as intersection$1 } from '../../array/intersection.mjs';
+import { uniq } from '../../array/uniq.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function intersection(...arrays) {
+    if (arrays.length === 0) {
+        return [];
+    }
+    if (!isArrayLikeObject(arrays[0])) {
+        return [];
+    }
+    let result = uniq(Array.from(arrays[0]));
+    for (let i = 1; i < arrays.length; i++) {
+        const array = arrays[i];
+        if (!isArrayLikeObject(array)) {
+            return [];
+        }
+        result = intersection$1(result, Array.from(array));
+    }
+    return result;
+}
+
+export { intersection };

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

@@ -0,0 +1,25 @@
+/**
+ * Returns the last element of an array.
+ *
+ * This function takes an array and returns the last element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * Unlike some implementations, this function is optimized for performance
+ * by directly accessing the last index of the array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to get the last element.
+ * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * const lastElement = last(arr);
+ * // lastElement will be 3
+ *
+ * const emptyArr: number[] = [];
+ * const noElement = last(emptyArr);
+ * // noElement will be undefined
+ */
+declare function last<T>(array: ArrayLike<T> | null | undefined): T | undefined;
+
+export { last };