es-toolkit 1.29.0 → 1.30.0-dev.963

package/dist/compat/_internal/isIndex.mjs

@@ -1,8 +1,8 @@
 const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
-function isIndex(value) {
+function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
     switch (typeof value) {
         case 'number': {
-            return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+            return Number.isInteger(value) && value >= 0 && value < length;
         }
         case 'symbol': {
             return false;

package/dist/compat/_internal/isPrototype.mjs

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

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

@@ -0,0 +1,91 @@
+/**
+ * Computes the difference between the primary array and another array using a comparator function.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values - The array containing elements to compare with the primary array.
+ * @param {(a: T1, b: T2) => boolean} comparator - A function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values` based on the comparator.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const values = [{ id: 2 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values, comparator);
+ * // result will be [{ id: 1 }, { id: 3 }]
+ */
+declare function differenceWith<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, comparator: (a: T1, b: T2) => boolean): T1[];
+/**
+ * Computes the difference between the primary array and two arrays using a comparator function.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to compare with the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to compare with the primary array.
+ * @param {(a: T1, b: T2 | T3) => boolean} comparator - A function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values1` or `values2` based on the comparator.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const values1 = [{ id: 2 }];
+ * const values2 = [{ id: 3 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values1, values2, comparator);
+ * // result will be [{ id: 1 }]
+ */
+declare function differenceWith<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, comparator: (a: T1, b: T2 | T3) => boolean): T1[];
+/**
+ * Computes the difference between the primary array and multiple arrays using a comparator function.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to compare with the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to compare with the primary array.
+ * @param {...Array<ArrayLike<T4> | ((a: T1, b: T2 | T3 | T4) => boolean)>} values - Additional arrays and an optional comparator function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements
+ * in `values1`, `values2`, or subsequent arrays. If a comparator function is provided, it will be used to compare elements;
+ * otherwise, [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero) algorithm will be used.
+ *
+ * @example
+ * // Example with comparator function
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }];
+ * const values1 = [{ id: 2 }];
+ * const values2 = [{ id: 3 }];
+ * const values3 = [{ id: 4 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values1, values2, values3, comparator);
+ * // result will be [{ id: 1 }]
+ *
+ * @example
+ * // Example without comparator function (behaves like `difference`)
+ * const array = [1, 2, 3, 4];
+ * const values1 = [2];
+ * const values2 = [3];
+ * const values3 = [4];
+ *
+ * const result = differenceWith(array, values1, values2, values3);
+ * // result will be [1]
+ */
+declare function differenceWith<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((a: T1, b: T2 | T3 | T4) => boolean)>): T1[];
+/**
+ * Computes the difference between the primary array and one or more arrays without using a comparator function.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The primary array to compare elements against.
+ * @param {...Array<ArrayLike<T>>} values - One or more arrays containing elements to compare with the primary array.
+ * @returns {T[]} A new array containing the elements from the primary array that do not match any elements in the provided arrays.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const values1 = [2];
+ * const values2 = [3];
+ *
+ * const result = differenceWith(array, values1, values2);
+ * // result will be [1]
+ */
+declare function differenceWith<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T>>): T[];
+
+export { differenceWith };

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

@@ -0,0 +1,91 @@
+/**
+ * Computes the difference between the primary array and another array using a comparator function.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values - The array containing elements to compare with the primary array.
+ * @param {(a: T1, b: T2) => boolean} comparator - A function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values` based on the comparator.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const values = [{ id: 2 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values, comparator);
+ * // result will be [{ id: 1 }, { id: 3 }]
+ */
+declare function differenceWith<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, comparator: (a: T1, b: T2) => boolean): T1[];
+/**
+ * Computes the difference between the primary array and two arrays using a comparator function.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to compare with the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to compare with the primary array.
+ * @param {(a: T1, b: T2 | T3) => boolean} comparator - A function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values1` or `values2` based on the comparator.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const values1 = [{ id: 2 }];
+ * const values2 = [{ id: 3 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values1, values2, comparator);
+ * // result will be [{ id: 1 }]
+ */
+declare function differenceWith<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, comparator: (a: T1, b: T2 | T3) => boolean): T1[];
+/**
+ * Computes the difference between the primary array and multiple arrays using a comparator function.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to compare with the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to compare with the primary array.
+ * @param {...Array<ArrayLike<T4> | ((a: T1, b: T2 | T3 | T4) => boolean)>} values - Additional arrays and an optional comparator function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements
+ * in `values1`, `values2`, or subsequent arrays. If a comparator function is provided, it will be used to compare elements;
+ * otherwise, [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero) algorithm will be used.
+ *
+ * @example
+ * // Example with comparator function
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }];
+ * const values1 = [{ id: 2 }];
+ * const values2 = [{ id: 3 }];
+ * const values3 = [{ id: 4 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values1, values2, values3, comparator);
+ * // result will be [{ id: 1 }]
+ *
+ * @example
+ * // Example without comparator function (behaves like `difference`)
+ * const array = [1, 2, 3, 4];
+ * const values1 = [2];
+ * const values2 = [3];
+ * const values3 = [4];
+ *
+ * const result = differenceWith(array, values1, values2, values3);
+ * // result will be [1]
+ */
+declare function differenceWith<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((a: T1, b: T2 | T3 | T4) => boolean)>): T1[];
+/**
+ * Computes the difference between the primary array and one or more arrays without using a comparator function.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The primary array to compare elements against.
+ * @param {...Array<ArrayLike<T>>} values - One or more arrays containing elements to compare with the primary array.
+ * @returns {T[]} A new array containing the elements from the primary array that do not match any elements in the provided arrays.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const values1 = [2];
+ * const values2 = [3];
+ *
+ * const result = differenceWith(array, values1, values2);
+ * // result will be [1]
+ */
+declare function differenceWith<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T>>): T[];
+
+export { differenceWith };

package/dist/compat/array/differenceWith.mjs

@@ -0,0 +1,19 @@
+import { last } from './last.mjs';
+import { difference } from '../../array/difference.mjs';
+import { differenceWith as differenceWith$1 } from '../../array/differenceWith.mjs';
+import { flattenArrayLike } from '../_internal/flattenArrayLike.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function differenceWith(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    const comparator = last(values);
+    const flattenedValues = flattenArrayLike(values);
+    if (typeof comparator === 'function') {
+        return differenceWith$1(Array.from(array), flattenedValues, comparator);
+    }
+    return difference(Array.from(array), flattenedValues);
+}
+
+export { differenceWith };

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

@@ -0,0 +1,182 @@
+/**
+ * Maps each element in a readonly array to a new array of values using an iteratee function.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(value: T, index: number, collection: readonly T[]) => U} iteratee - The function invoked per iteration.
+ * @returns {U[]} - Returns the new mapped array.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * map(array, value => value * 2); // => [2, 4, 6]
+ */
+declare function map<T, U>(collection: readonly T[], iteratee: (value: T, index: number, collection: readonly T[]) => U): U[];
+/**
+ * Maps each element in a readonly array to a boolean array based on a partial object match.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {Partial<T>} iteratee - The partial object to match against each element.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(objects, { a: 1 }); // => [true, false, false]
+ */
+declare function map<T>(collection: readonly T[], iteratee: Partial<T>): boolean[];
+/**
+ * Maps each element in a readonly array to a boolean array based on a property-value pair match.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {[keyof T, unknown]} iteratee - The property-value pair to match against each element.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(objects, ['a', 1]); // => [true, false, false]
+ */
+declare function map<T>(collection: readonly T[], iteratee: [keyof T, unknown]): boolean[];
+/**
+ * Maps each element in a readonly array to an array of property values.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {K} iteratee - The key of the property to extract from each element.
+ * @returns {Array<T[K]>} - Returns an array of property values.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(objects, 'a'); // => [1, 2, 3]
+ */
+declare function map<T, K extends keyof T>(collection: readonly T[], iteratee: K): Array<T[K]>;
+/**
+ * Maps each element in a readonly array to itself if no iteratee is provided.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {null | undefined} [iteratee] - Optional iteratee.
+ * @returns {T[]} - Returns the original array.
+ *
+ * @example
+ * const numbers = [1, 2, 3];
+ * map(numbers); // => [1, 2, 3]
+ */
+declare function map<T>(collection: readonly T[], iteratee?: null | undefined): T[];
+/**
+ * Maps each element in an ArrayLike object to a new array of values using an iteratee function.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @returns {U[]} - Returns the new mapped array.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * map(arrayLike, value => value * 2); // => [2, 4, 6]
+ */
+declare function map<T, U>(collection: ArrayLike<T>, iteratee: (value: T, index: number, collection: ArrayLike<T>) => U): U[];
+/**
+ * Maps each element in an ArrayLike object to a boolean array based on a partial object match.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {Partial<T>} iteratee - The partial object to match against each element.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const arrayLike = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(arrayLike, { a: 1 }); // => [true, false, false]
+ */
+declare function map<T>(collection: ArrayLike<T>, iteratee: Partial<T>): boolean[];
+/**
+ * Maps each element in an ArrayLike object to a boolean array based on a property-value pair match.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {[keyof T, unknown]} iteratee - The property-value pair to match against each element.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const arrayLike = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(arrayLike, ['a', 1]); // => [true, false, false]
+ */
+declare function map<T>(collection: ArrayLike<T>, iteratee: [keyof T, unknown]): boolean[];
+/**
+ * Maps each element in an ArrayLike object to an array of property values.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {K} iteratee - The key of the property to extract from each element.
+ * @returns {Array<T[K]>} - Returns an array of property values.
+ *
+ * @example
+ * const arrayLike = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(arrayLike, 'a'); // => [1, 2, 3]
+ */
+declare function map<T, K extends keyof T>(collection: ArrayLike<T>, iteratee: K): Array<T[K]>;
+/**
+ * Maps each element in an ArrayLike object to itself if no iteratee is provided.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {null | undefined} [iteratee] - Optional iteratee.
+ * @returns {ArrayLike<T>} - Returns the original ArrayLike object.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * map(arrayLike); // => {0: 1, 1: 2, 2: 3, length: 3}
+ */
+declare function map<T, U>(collection: ArrayLike<T>, iteratee?: null | undefined): ArrayLike<T>;
+/**
+ * Maps each value in an object to a new array of values using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(value: T[keyof T], key: string, collection: T) => U} iteratee - The function invoked per iteration.
+ * @returns {U[]} - Returns the new mapped array.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * map(obj, (value, key) => `${key}: ${value}`); // => ['a: 1', 'b: 2', 'c: 3']
+ */
+declare function map<T extends object, U>(collection: T, iteratee: (value: T[keyof T], key: string, collection: T) => U): U[];
+/**
+ * Maps each value in an object to a boolean array based on a partial object match.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {Partial<T[keyof T]>} iteratee - The partial object to match against each value.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const obj = { a: { x: 1 }, b: { x: 2 }, c: { x: 3 } };
+ * map(obj, { x: 1 }); // => [true, false, false]
+ */
+declare function map<T>(object: T, iteratee: Partial<T[keyof T]>): boolean[];
+/**
+ * Maps each value in an object to a boolean array based on a property-value pair match.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {[keyof T[keyof T], unknown]} iteratee - The property-value pair to match against each value.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const obj = { a: { x: 1 }, b: { x: 2 }, c: { x: 3 } };
+ * map(obj, ['x', 1]); // => [true, false, false]
+ */
+declare function map<T>(object: T, iteratee: [keyof T[keyof T], unknown]): boolean[];
+/**
+ * Maps each value in an object to an array of property values.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {K} iteratee - The key of the property to extract from each value.
+ * @returns {Array<T[keyof T][K]>} - Returns an array of property values.
+ *
+ * @example
+ * const obj = { a: { x: 1 }, b: { x: 2 }, c: { x: 3 } };
+ * map(obj, 'x'); // => [1, 2, 3]
+ */
+declare function map<T, K extends keyof T[keyof T]>(object: T, iteratee: K): Array<T[keyof T][K]>;
+/**
+ * Maps each value in an object to itself if no iteratee is provided.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {null | undefined} [iteratee] - Optional iteratee.
+ * @returns {U[]} - Returns the original object values as an array.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * map(obj); // => [1, 2, 3]
+ */
+declare function map<T extends object, U>(object: T, iteratee?: null | undefined): U[];
+
+export { map };

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

@@ -0,0 +1,182 @@
+/**
+ * Maps each element in a readonly array to a new array of values using an iteratee function.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(value: T, index: number, collection: readonly T[]) => U} iteratee - The function invoked per iteration.
+ * @returns {U[]} - Returns the new mapped array.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * map(array, value => value * 2); // => [2, 4, 6]
+ */
+declare function map<T, U>(collection: readonly T[], iteratee: (value: T, index: number, collection: readonly T[]) => U): U[];
+/**
+ * Maps each element in a readonly array to a boolean array based on a partial object match.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {Partial<T>} iteratee - The partial object to match against each element.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(objects, { a: 1 }); // => [true, false, false]
+ */
+declare function map<T>(collection: readonly T[], iteratee: Partial<T>): boolean[];
+/**
+ * Maps each element in a readonly array to a boolean array based on a property-value pair match.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {[keyof T, unknown]} iteratee - The property-value pair to match against each element.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(objects, ['a', 1]); // => [true, false, false]
+ */
+declare function map<T>(collection: readonly T[], iteratee: [keyof T, unknown]): boolean[];
+/**
+ * Maps each element in a readonly array to an array of property values.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {K} iteratee - The key of the property to extract from each element.
+ * @returns {Array<T[K]>} - Returns an array of property values.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(objects, 'a'); // => [1, 2, 3]
+ */
+declare function map<T, K extends keyof T>(collection: readonly T[], iteratee: K): Array<T[K]>;
+/**
+ * Maps each element in a readonly array to itself if no iteratee is provided.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {null | undefined} [iteratee] - Optional iteratee.
+ * @returns {T[]} - Returns the original array.
+ *
+ * @example
+ * const numbers = [1, 2, 3];
+ * map(numbers); // => [1, 2, 3]
+ */
+declare function map<T>(collection: readonly T[], iteratee?: null | undefined): T[];
+/**
+ * Maps each element in an ArrayLike object to a new array of values using an iteratee function.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @returns {U[]} - Returns the new mapped array.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * map(arrayLike, value => value * 2); // => [2, 4, 6]
+ */
+declare function map<T, U>(collection: ArrayLike<T>, iteratee: (value: T, index: number, collection: ArrayLike<T>) => U): U[];
+/**
+ * Maps each element in an ArrayLike object to a boolean array based on a partial object match.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {Partial<T>} iteratee - The partial object to match against each element.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const arrayLike = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(arrayLike, { a: 1 }); // => [true, false, false]
+ */
+declare function map<T>(collection: ArrayLike<T>, iteratee: Partial<T>): boolean[];
+/**
+ * Maps each element in an ArrayLike object to a boolean array based on a property-value pair match.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {[keyof T, unknown]} iteratee - The property-value pair to match against each element.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const arrayLike = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(arrayLike, ['a', 1]); // => [true, false, false]
+ */
+declare function map<T>(collection: ArrayLike<T>, iteratee: [keyof T, unknown]): boolean[];
+/**
+ * Maps each element in an ArrayLike object to an array of property values.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {K} iteratee - The key of the property to extract from each element.
+ * @returns {Array<T[K]>} - Returns an array of property values.
+ *
+ * @example
+ * const arrayLike = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * map(arrayLike, 'a'); // => [1, 2, 3]
+ */
+declare function map<T, K extends keyof T>(collection: ArrayLike<T>, iteratee: K): Array<T[K]>;
+/**
+ * Maps each element in an ArrayLike object to itself if no iteratee is provided.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {null | undefined} [iteratee] - Optional iteratee.
+ * @returns {ArrayLike<T>} - Returns the original ArrayLike object.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * map(arrayLike); // => {0: 1, 1: 2, 2: 3, length: 3}
+ */
+declare function map<T, U>(collection: ArrayLike<T>, iteratee?: null | undefined): ArrayLike<T>;
+/**
+ * Maps each value in an object to a new array of values using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(value: T[keyof T], key: string, collection: T) => U} iteratee - The function invoked per iteration.
+ * @returns {U[]} - Returns the new mapped array.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * map(obj, (value, key) => `${key}: ${value}`); // => ['a: 1', 'b: 2', 'c: 3']
+ */
+declare function map<T extends object, U>(collection: T, iteratee: (value: T[keyof T], key: string, collection: T) => U): U[];
+/**
+ * Maps each value in an object to a boolean array based on a partial object match.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {Partial<T[keyof T]>} iteratee - The partial object to match against each value.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const obj = { a: { x: 1 }, b: { x: 2 }, c: { x: 3 } };
+ * map(obj, { x: 1 }); // => [true, false, false]
+ */
+declare function map<T>(object: T, iteratee: Partial<T[keyof T]>): boolean[];
+/**
+ * Maps each value in an object to a boolean array based on a property-value pair match.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {[keyof T[keyof T], unknown]} iteratee - The property-value pair to match against each value.
+ * @returns {boolean[]} - Returns an array of booleans indicating matches.
+ *
+ * @example
+ * const obj = { a: { x: 1 }, b: { x: 2 }, c: { x: 3 } };
+ * map(obj, ['x', 1]); // => [true, false, false]
+ */
+declare function map<T>(object: T, iteratee: [keyof T[keyof T], unknown]): boolean[];
+/**
+ * Maps each value in an object to an array of property values.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {K} iteratee - The key of the property to extract from each value.
+ * @returns {Array<T[keyof T][K]>} - Returns an array of property values.
+ *
+ * @example
+ * const obj = { a: { x: 1 }, b: { x: 2 }, c: { x: 3 } };
+ * map(obj, 'x'); // => [1, 2, 3]
+ */
+declare function map<T, K extends keyof T[keyof T]>(object: T, iteratee: K): Array<T[keyof T][K]>;
+/**
+ * Maps each value in an object to itself if no iteratee is provided.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {null | undefined} [iteratee] - Optional iteratee.
+ * @returns {U[]} - Returns the original object values as an array.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * map(obj); // => [1, 2, 3]
+ */
+declare function map<T extends object, U>(object: T, iteratee?: null | undefined): U[];
+
+export { map };

package/dist/compat/array/map.mjs

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

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

@@ -0,0 +1,14 @@
+/**
+ * Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned.
+ *
+ * @param {ArrayLike<T> | null | undefined} array - The array to query.
+ * @param {number} [n=0] - The index of the element to return.
+ * @return {T | undefined} Returns the nth element of `array`.
+ *
+ * @example
+ * nth([1, 2, 3], 1); // => 2
+ * nth([1, 2, 3], -1); // => 3
+ */
+declare function nth<T>(array: ArrayLike<T> | null | undefined, n?: number): T | undefined;
+
+export { nth };

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

@@ -0,0 +1,14 @@
+/**
+ * Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned.
+ *
+ * @param {ArrayLike<T> | null | undefined} array - The array to query.
+ * @param {number} [n=0] - The index of the element to return.
+ * @return {T | undefined} Returns the nth element of `array`.
+ *
+ * @example
+ * nth([1, 2, 3], 1); // => 2
+ * nth([1, 2, 3], -1); // => 3
+ */
+declare function nth<T>(array: ArrayLike<T> | null | undefined, n?: number): T | undefined;
+
+export { nth };

package/dist/compat/array/nth.mjs

@@ -0,0 +1,15 @@
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+import { toInteger } from '../util/toInteger.mjs';
+
+function nth(array, n = 0) {
+    if (!isArrayLikeObject(array) || array.length === 0) {
+        return undefined;
+    }
+    n = toInteger(n);
+    if (n < 0) {
+        n += array.length;
+    }
+    return array[n];
+}
+
+export { nth };