es-toolkit 1.35.0 → 1.36.0-dev.1215

package/dist/compat/_internal/copyArray.mjs

@@ -0,0 +1,12 @@
+function copyArray(source, array) {
+    const length = source.length;
+    if (array == null) {
+        array = Array(length);
+    }
+    for (let i = 0; i < length; i++) {
+        array[i] = source[i];
+    }
+    return array;
+}
+
+export { copyArray as default };

package/dist/compat/_internal/mapToEntries.mjs

@@ -0,0 +1,11 @@
+function mapToEntries(map) {
+    const arr = new Array(map.size);
+    const keys = map.keys();
+    const values = map.values();
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = [keys.next().value, values.next().value];
+    }
+    return arr;
+}
+
+export { mapToEntries };

package/dist/compat/_internal/setToEntries.mjs

@@ -0,0 +1,11 @@
+function setToEntries(set) {
+    const arr = new Array(set.size);
+    const values = set.values();
+    for (let i = 0; i < arr.length; i++) {
+        const value = values.next().value;
+        arr[i] = [value, value];
+    }
+    return arr;
+}
+
+export { setToEntries };

package/dist/compat/_internal/toKey.mjs

@@ -2,10 +2,10 @@ function toKey(value) {
     if (typeof value === 'string' || typeof value === 'symbol') {
         return value;
     }
-    if (Object.is(value.valueOf(), -0)) {
+    if (Object.is(value?.valueOf?.(), -0)) {
         return '-0';
     }
-    return value.toString();
+    return String(value);
 }
 
 export { toKey };

package/dist/compat/array/find.mjs

@@ -8,10 +8,9 @@ function find(source, _doesMatch, fromIndex = 0) {
         fromIndex = Math.max(source.length + fromIndex, 0);
     }
     const doesMatch = iteratee(_doesMatch);
-    const values = Array.isArray(source) ? source.slice(fromIndex) : Object.values(source).slice(fromIndex);
     if (typeof doesMatch === 'function' && !Array.isArray(source)) {
-        const keys = Object.keys(source).slice(fromIndex);
-        for (let i = 0; i < keys.length; i++) {
+        const keys = Object.keys(source);
+        for (let i = fromIndex; i < keys.length; i++) {
             const key = keys[i];
             const value = source[key];
             if (doesMatch(value, key, source)) {
@@ -20,6 +19,7 @@ function find(source, _doesMatch, fromIndex = 0) {
         }
         return undefined;
     }
+    const values = Array.isArray(source) ? source.slice(fromIndex) : Object.values(source).slice(fromIndex);
     return values.find(doesMatch);
 }
 

package/dist/compat/array/findLast.mjs

@@ -14,9 +14,8 @@ function findLast(source, _doesMatch, fromIndex) {
         fromIndex = Math.min(fromIndex, length - 1);
     }
     const doesMatch = iteratee(_doesMatch);
-    const values = Array.isArray(source) ? source.slice(0, fromIndex + 1) : Object.values(source).slice(0, fromIndex + 1);
     if (typeof doesMatch === 'function' && !Array.isArray(source)) {
-        const keys = Object.keys(source).slice(0, fromIndex + 1);
+        const keys = Object.keys(source);
         for (let i = fromIndex; i >= 0; i--) {
             const key = keys[i];
             const value = source[key];
@@ -26,6 +25,7 @@ function findLast(source, _doesMatch, fromIndex) {
         }
         return undefined;
     }
+    const values = Array.isArray(source) ? source.slice(0, fromIndex + 1) : Object.values(source).slice(0, fromIndex + 1);
     return values.findLast(doesMatch);
 }
 

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

@@ -0,0 +1,20 @@
+/**
+ * Maps each element in the collection using the iteratee function and flattens the result by one level.
+ * The iteratee is invoked with three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=identity] The function invoked per iteration.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * function duplicate(n) {
+ *   return [n, n];
+ * }
+ *
+ * flatMap([1, 2], duplicate);
+ * // => [1, 1, 2, 2]
+ */
+declare function flatMap<T, R>(collection: T[] | Record<string, T> | null | undefined, iteratee?: ((value: T, index: number | string, collection: unknown) => R | R[] | null | undefined) | keyof T | object): R[];
+
+export { flatMap };

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

@@ -0,0 +1,20 @@
+/**
+ * Maps each element in the collection using the iteratee function and flattens the result by one level.
+ * The iteratee is invoked with three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=identity] The function invoked per iteration.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * function duplicate(n) {
+ *   return [n, n];
+ * }
+ *
+ * flatMap([1, 2], duplicate);
+ * // => [1, 1, 2, 2]
+ */
+declare function flatMap<T, R>(collection: T[] | Record<string, T> | null | undefined, iteratee?: ((value: T, index: number | string, collection: unknown) => R | R[] | null | undefined) | keyof T | object): R[];
+
+export { flatMap };

package/dist/compat/array/flatMap.mjs

@@ -0,0 +1,13 @@
+import { flatten } from './flatten.mjs';
+import { map } from './map.mjs';
+import { isNil } from '../../predicate/isNil.mjs';
+
+function flatMap(collection, iteratee) {
+    if (isNil(collection)) {
+        return [];
+    }
+    const mapped = isNil(iteratee) ? map(collection) : map(collection, iteratee);
+    return flatten(mapped, 1);
+}
+
+export { flatMap };

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

@@ -0,0 +1,106 @@
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' 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 'forEachRight' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEachRight([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 3 2
+ * // 2 1
+ * // 1 0
+ *
+ */
+declare function forEachRight<T>(array: T[], callback?: (value: T, index: number, array: T[]) => unknown): T[];
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' 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 'forEachRight' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEachRight([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 3 2
+ * // 2 1
+ * // 1 0
+ *
+ */
+declare function forEachRight<T>(array: readonly T[], callback?: (value: T, index: number, array: T[]) => unknown): readonly T[];
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' 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 'forEachRight' was called upon.
+ * @returns {T} Returns the original string.
+ *
+ * @example
+ * forEachRight('abc', (char, index, string) => console.log(char, index));
+ * // Output:
+ * // 'c' 2
+ * // 'b' 1
+ * // 'a' 0
+ */
+declare function forEachRight<T extends string | null | undefined>(string: T, callback?: (char: string, index: number, string: string) => unknown): T;
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' 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 'forEachRight' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEachRight([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 3 2
+ * // 2 1
+ * // 1 0
+ *
+ */
+declare function forEachRight<T>(array: ArrayLike<T>, callback?: (value: T, index: number, array: ArrayLike<T>) => unknown): ArrayLike<T>;
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' for each element.
+ *
+ * @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 'forEachRight' was called upon.
+ * @returns {T} Returns the original object.
+ *
+ * @example
+ * forEachRight({'a': 1, 'b': 2 }, (value, key, object) => console.log(value, key));
+ * // Output:
+ * // 2 'b'
+ * // 1 'a'
+ */
+declare function forEachRight<T extends object | null | undefined>(object: T, callback?: (value: T[keyof T], key: keyof T, object: T) => unknown): T;
+
+export { forEachRight };

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

@@ -0,0 +1,106 @@
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' 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 'forEachRight' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEachRight([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 3 2
+ * // 2 1
+ * // 1 0
+ *
+ */
+declare function forEachRight<T>(array: T[], callback?: (value: T, index: number, array: T[]) => unknown): T[];
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' 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 'forEachRight' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEachRight([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 3 2
+ * // 2 1
+ * // 1 0
+ *
+ */
+declare function forEachRight<T>(array: readonly T[], callback?: (value: T, index: number, array: T[]) => unknown): readonly T[];
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' 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 'forEachRight' was called upon.
+ * @returns {T} Returns the original string.
+ *
+ * @example
+ * forEachRight('abc', (char, index, string) => console.log(char, index));
+ * // Output:
+ * // 'c' 2
+ * // 'b' 1
+ * // 'a' 0
+ */
+declare function forEachRight<T extends string | null | undefined>(string: T, callback?: (char: string, index: number, string: string) => unknown): T;
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' 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 'forEachRight' was called upon.
+ * @returns {T} Returns the original array.
+ *
+ * @example
+ * forEachRight([1, 2, 3], (value, index, array) => console.log(value, index));
+ * // Output:
+ * // 3 2
+ * // 2 1
+ * // 1 0
+ *
+ */
+declare function forEachRight<T>(array: ArrayLike<T>, callback?: (value: T, index: number, array: ArrayLike<T>) => unknown): ArrayLike<T>;
+/**
+ * Iterates over elements of 'array' from right to left and invokes 'callback' for each element.
+ *
+ * @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 'forEachRight' was called upon.
+ * @returns {T} Returns the original object.
+ *
+ * @example
+ * forEachRight({'a': 1, 'b': 2 }, (value, key, object) => console.log(value, key));
+ * // Output:
+ * // 2 'b'
+ * // 1 'a'
+ */
+declare function forEachRight<T extends object | null | undefined>(object: T, callback?: (value: T[keyof T], key: keyof T, object: T) => unknown): T;
+
+export { forEachRight };

package/dist/compat/array/forEachRight.mjs

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

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

@@ -0,0 +1,55 @@
+/**
+ * Maps each element of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are the corresponding elements.
+ * If there are multiple elements generating the same key, the last element among them is used
+ * as the value.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The type of keys.
+ * @param {T[]} arr - The array of elements to be mapped.
+ * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = keyBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: { category: 'fruit', name: 'banana' },
+ * //   vegetable: { category: 'vegetable', name: 'carrot' }
+ * // }
+ */
+declare function groupBy<T, K extends PropertyKey>(source: ArrayLike<T> | null | undefined, getKeyFromItem?: ((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey | null): Record<K, T[]>;
+/**
+ * Groups the elements of an object based on a provided key-generating function.
+ *
+ * This function takes an object and a function that generates a key from each value. It returns
+ * an object where the keys are the generated keys and the values are arrays of elements that share
+ * the same key.
+ *
+ * @template T - The type of values in the object.
+ * @template K - The type of keys.
+ * @param {Record<any, T> | null | undefined} source - The object to group.
+ * @param {Function | PropertyKey | Array | Object} [getKeyFromItem] - The iteratee to transform keys.
+ *   - If a function is provided, it's invoked for each element in the collection.
+ *   - If a property name (string) is provided, that property of each element is used as the key.
+ *   - If a property-value pair (array) is provided, elements with matching property values are used.
+ *   - If a partial object is provided, elements with matching properties are used.
+ * @returns {Record<K, T>} An object where each key is associated with an array of elements that
+ * share that key.
+ *
+ * @example
+ * // Using an object
+ * const obj = { a: { category: 'fruit' }, b: { category: 'vegetable' }, c: { category: 'fruit' } };
+ * const result = groupBy(obj, 'category');
+ * // => { fruit: [{ category: 'fruit' }, { category: 'fruit' }], vegetable: [{ category: 'vegetable' }] }
+ */
+declare function groupBy<T, K extends PropertyKey>(source: Record<any, T> | null | undefined, getKeyFromItem?: ((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey | null): Record<K, T[]>;
+
+export { groupBy };

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

@@ -0,0 +1,55 @@
+/**
+ * Maps each element of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are the corresponding elements.
+ * If there are multiple elements generating the same key, the last element among them is used
+ * as the value.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The type of keys.
+ * @param {T[]} arr - The array of elements to be mapped.
+ * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = keyBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: { category: 'fruit', name: 'banana' },
+ * //   vegetable: { category: 'vegetable', name: 'carrot' }
+ * // }
+ */
+declare function groupBy<T, K extends PropertyKey>(source: ArrayLike<T> | null | undefined, getKeyFromItem?: ((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey | null): Record<K, T[]>;
+/**
+ * Groups the elements of an object based on a provided key-generating function.
+ *
+ * This function takes an object and a function that generates a key from each value. It returns
+ * an object where the keys are the generated keys and the values are arrays of elements that share
+ * the same key.
+ *
+ * @template T - The type of values in the object.
+ * @template K - The type of keys.
+ * @param {Record<any, T> | null | undefined} source - The object to group.
+ * @param {Function | PropertyKey | Array | Object} [getKeyFromItem] - The iteratee to transform keys.
+ *   - If a function is provided, it's invoked for each element in the collection.
+ *   - If a property name (string) is provided, that property of each element is used as the key.
+ *   - If a property-value pair (array) is provided, elements with matching property values are used.
+ *   - If a partial object is provided, elements with matching properties are used.
+ * @returns {Record<K, T>} An object where each key is associated with an array of elements that
+ * share that key.
+ *
+ * @example
+ * // Using an object
+ * const obj = { a: { category: 'fruit' }, b: { category: 'vegetable' }, c: { category: 'fruit' } };
+ * const result = groupBy(obj, 'category');
+ * // => { fruit: [{ category: 'fruit' }, { category: 'fruit' }], vegetable: [{ category: 'vegetable' }] }
+ */
+declare function groupBy<T, K extends PropertyKey>(source: Record<any, T> | null | undefined, getKeyFromItem?: ((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey | null): Record<K, T[]>;
+
+export { groupBy };

package/dist/compat/array/groupBy.mjs

@@ -0,0 +1,15 @@
+import { groupBy as groupBy$1 } from '../../array/groupBy.mjs';
+import { identity } from '../../function/identity.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function groupBy(source, _getKeyFromItem) {
+    if (source == null) {
+        return {};
+    }
+    const items = isArrayLike(source) ? Array.from(source) : Object.values(source);
+    const getKeyFromItem = iteratee(_getKeyFromItem ?? identity);
+    return groupBy$1(items, getKeyFromItem);
+}
+
+export { groupBy };

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

@@ -0,0 +1,65 @@
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
+ *
+ * @template T
+ * @template U
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {(value: T) => value is U} predicate - The function invoked per iteration.
+ * @returns {[U[], Array<Exclude<T, U>>]} - Returns the array of grouped elements.
+ *
+ * @example
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
+ *
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
+ *
+ * partition([1, 2, 3, 4], ['a', 2]);
+ */
+declare function partition<T, U extends T>(source: ArrayLike<T> | null | undefined, predicate: (value: T) => value is U): [U[], Array<Exclude<T, U>>];
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+ * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ *
+ * @example
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
+ *
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
+ *
+ * partition([1, 2, 3, 4], ['a', 2]);
+ * // => [[2], [1, 3, 4]]
+ */
+declare function partition<T>(source: ArrayLike<T> | null | undefined, predicate?: ((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>): [T[], T[]];
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {((item: T[keyof T], key: keyof T) => unknown) | Partial<T[keyof T]> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+ * @returns {[T[keyof T][], T[keyof T][]]} - Returns the array of grouped elements.
+ *
+ * @example
+ * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
+ * // => [[2], [1, 3]]
+ *
+ * partition({ a: 1, b: 2, c: 3 }, 'a');
+ * // => [[1], [2, 3]]
+ *
+ * partition({ a: 1, b: 2, c: 3 }, ['a', 1]);
+ * // => [[1], [2, 3]]
+ */
+declare function partition<T extends object>(object: T | null | undefined, predicate?: ((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
+
+export { partition };

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

@@ -0,0 +1,65 @@
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
+ *
+ * @template T
+ * @template U
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {(value: T) => value is U} predicate - The function invoked per iteration.
+ * @returns {[U[], Array<Exclude<T, U>>]} - Returns the array of grouped elements.
+ *
+ * @example
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
+ *
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
+ *
+ * partition([1, 2, 3, 4], ['a', 2]);
+ */
+declare function partition<T, U extends T>(source: ArrayLike<T> | null | undefined, predicate: (value: T) => value is U): [U[], Array<Exclude<T, U>>];
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+ * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ *
+ * @example
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
+ *
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
+ *
+ * partition([1, 2, 3, 4], ['a', 2]);
+ * // => [[2], [1, 3, 4]]
+ */
+declare function partition<T>(source: ArrayLike<T> | null | undefined, predicate?: ((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>): [T[], T[]];
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {((item: T[keyof T], key: keyof T) => unknown) | Partial<T[keyof T]> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+ * @returns {[T[keyof T][], T[keyof T][]]} - Returns the array of grouped elements.
+ *
+ * @example
+ * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
+ * // => [[2], [1, 3]]
+ *
+ * partition({ a: 1, b: 2, c: 3 }, 'a');
+ * // => [[1], [2, 3]]
+ *
+ * partition({ a: 1, b: 2, c: 3 }, ['a', 1]);
+ * // => [[1], [2, 3]]
+ */
+declare function partition<T extends object>(object: T | null | undefined, predicate?: ((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
+
+export { partition };