es-toolkit 1.15.1 → 1.16.0

package/dist/compat/_internal/getSymbols.mjs

@@ -1,6 +1,5 @@
 function getSymbols(object) {
-    return Object.getOwnPropertySymbols(object)
-        .filter(symbol => object.propertyIsEnumerable(symbol));
+    return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol));
 }
 
 export { getSymbols };

package/dist/compat/_internal/toKey.mjs

@@ -0,0 +1,13 @@
+import { isSymbol } from '../predicate/isSymbol.mjs';
+
+function toKey(value) {
+    if (typeof value === 'string' || isSymbol(value)) {
+        return value;
+    }
+    if (Object.is(value?.valueOf(), -0)) {
+        return '-0';
+    }
+    return `${value}`;
+}
+
+export { toKey };

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

@@ -0,0 +1,122 @@
+/**
+ * Finds the first item in an array that matches the given predicate function.
+ *
+ * @template T
+ * @param {T[]} arr - The array to search through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @returns {T | undefined} - The first item that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = find(items, (item) => item > 3);
+ * console.log(result); // 4
+ */
+declare function find<T>(arr: readonly T[], doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): T | undefined;
+/**
+ * Finds the first item in an array that matches the given partial object.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {T | undefined} - The first item that matches the partial object, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = find(items, { name: 'Bob' });
+ * console.log(result); // { id: 2, name: 'Bob' }
+ */
+declare function find<T>(arr: readonly T[], doesMatch: Partial<T>): T | undefined;
+/**
+ * Finds the first item in an array that matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = find(items, ['name', 'Alice']);
+ * console.log(result); // { id: 1, name: 'Alice' }
+ */
+declare function find<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown]): T | undefined;
+/**
+ * Finds the first item in an array that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {T | undefined} - The first item that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = find(items, 'name');
+ * console.log(result); // { id: 1, name: 'Alice' }
+ */
+declare function find<T>(arr: readonly T[], propertyToCheck: string): T | undefined;
+/**
+ * Finds the first item in an object that matches the given predicate function.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to search through.
+ * @param {(item: T[keyof T], index: number, arr: T) => unknown} doesMatch - A function that takes an item, its key, and the object, and returns a truthy value if the item matches the criteria.
+ * @returns {T | undefined} - The first property value that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = find(obj, (item) => item > 2);
+ * console.log(result); // 3
+ */
+declare function find<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: number, object: T) => unknown): T | undefined;
+/**
+ * Finds the first item in an object that matches the given partial value.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to search through.
+ * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @returns {T | undefined} - The first property value that matches the partial value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial value
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * const result = find(obj, { name: 'Bob' });
+ * console.log(result); // { id: 2, name: 'Bob' }
+ */
+declare function find<T extends Record<string, unknown>>(object: T, doesMatch: Partial<T[keyof T]>): T | undefined;
+/**
+ * Finds the first item in an object that matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} object - The object to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * const result = find(items, ['name', 'Alice']);
+ * console.log(result); // { id: 1, name: 'Alice' }
+ */
+declare function find<T extends Record<string, unknown>>(object: T, doesMatchProperty: [keyof T, unknown]): T | undefined;
+/**
+ * Finds the first item in an object that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to search through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {T | undefined} - The first property value that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * const result = find(obj, 'name');
+ * console.log(result); // { id: 1, name: 'Alice' }
+ */
+declare function find<T extends Record<string, unknown>>(object: T, propertyToCheck: string): T | undefined;
+
+export { find };

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

@@ -0,0 +1,122 @@
+/**
+ * Finds the first item in an array that matches the given predicate function.
+ *
+ * @template T
+ * @param {T[]} arr - The array to search through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @returns {T | undefined} - The first item that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = find(items, (item) => item > 3);
+ * console.log(result); // 4
+ */
+declare function find<T>(arr: readonly T[], doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): T | undefined;
+/**
+ * Finds the first item in an array that matches the given partial object.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {T | undefined} - The first item that matches the partial object, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = find(items, { name: 'Bob' });
+ * console.log(result); // { id: 2, name: 'Bob' }
+ */
+declare function find<T>(arr: readonly T[], doesMatch: Partial<T>): T | undefined;
+/**
+ * Finds the first item in an array that matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = find(items, ['name', 'Alice']);
+ * console.log(result); // { id: 1, name: 'Alice' }
+ */
+declare function find<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown]): T | undefined;
+/**
+ * Finds the first item in an array that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {T | undefined} - The first item that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = find(items, 'name');
+ * console.log(result); // { id: 1, name: 'Alice' }
+ */
+declare function find<T>(arr: readonly T[], propertyToCheck: string): T | undefined;
+/**
+ * Finds the first item in an object that matches the given predicate function.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to search through.
+ * @param {(item: T[keyof T], index: number, arr: T) => unknown} doesMatch - A function that takes an item, its key, and the object, and returns a truthy value if the item matches the criteria.
+ * @returns {T | undefined} - The first property value that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = find(obj, (item) => item > 2);
+ * console.log(result); // 3
+ */
+declare function find<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: number, object: T) => unknown): T | undefined;
+/**
+ * Finds the first item in an object that matches the given partial value.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to search through.
+ * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @returns {T | undefined} - The first property value that matches the partial value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial value
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * const result = find(obj, { name: 'Bob' });
+ * console.log(result); // { id: 2, name: 'Bob' }
+ */
+declare function find<T extends Record<string, unknown>>(object: T, doesMatch: Partial<T[keyof T]>): T | undefined;
+/**
+ * Finds the first item in an object that matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} object - The object to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * const result = find(items, ['name', 'Alice']);
+ * console.log(result); // { id: 1, name: 'Alice' }
+ */
+declare function find<T extends Record<string, unknown>>(object: T, doesMatchProperty: [keyof T, unknown]): T | undefined;
+/**
+ * Finds the first item in an object that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to search through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {T | undefined} - The first property value that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * const result = find(obj, 'name');
+ * console.log(result); // { id: 1, name: 'Alice' }
+ */
+declare function find<T extends Record<string, unknown>>(object: T, propertyToCheck: string): T | undefined;
+
+export { find };

package/dist/compat/array/find.mjs

@@ -0,0 +1,42 @@
+import { property } from '../object/property.mjs';
+import { matches } from '../predicate/matches.mjs';
+import { matchesProperty } from '../predicate/matchesProperty.mjs';
+
+function find(source, doesMatch) {
+    let values = source;
+    if (!Array.isArray(source)) {
+        values = Object.values(source);
+    }
+    switch (typeof doesMatch) {
+        case 'function': {
+            if (!Array.isArray(source)) {
+                const entries = Object.entries(source);
+                for (let i = 0; i < entries.length; i++) {
+                    const entry = entries[i];
+                    const key = entry[0];
+                    const value = entry[1];
+                    if (doesMatch(value, key, source)) {
+                        return value;
+                    }
+                }
+                return undefined;
+            }
+            return values.find(doesMatch);
+        }
+        case 'object': {
+            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
+                const key = doesMatch[0];
+                const value = doesMatch[1];
+                return values.find(matchesProperty(key, value));
+            }
+            else {
+                return values.find(matches(doesMatch));
+            }
+        }
+        case 'string': {
+            return values.find(property(doesMatch));
+        }
+    }
+}
+
+export { find };

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

@@ -0,0 +1,62 @@
+/**
+ * Finds the index of the first item in an array that matches the given predicate function.
+ *
+ * @template T
+ * @param {T[]} arr - The array to search through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @returns {number} - The index of the first item that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = find(items, (item) => item > 3);
+ * console.log(result); // 4
+ */
+declare function findIndex<T>(arr: readonly T[], doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): number;
+/**
+ * Finds the index of the first item in an array that matches the given partial object.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {number} - The index of the first item that matches the partial object, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findIndex(items, { name: 'Bob' });
+ * console.log(result); // 1
+ */
+declare function findIndex<T>(arr: readonly T[], doesMatch: Partial<T>): number;
+/**
+ * Finds the index of the first item in an array that matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {number} - The index of the first item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findIndex(items, ['name', 'Alice']);
+ * console.log(result); // 0
+ */
+declare function findIndex<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown]): number;
+/**
+ * Finds the index of the first item in an array that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {number} - The index of the first item that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findIndex(items, 'name');
+ * console.log(result); // 0
+ */
+declare function findIndex<T>(arr: readonly T[], propertyToCheck: string): number;
+
+export { findIndex };

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

@@ -0,0 +1,62 @@
+/**
+ * Finds the index of the first item in an array that matches the given predicate function.
+ *
+ * @template T
+ * @param {T[]} arr - The array to search through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @returns {number} - The index of the first item that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = find(items, (item) => item > 3);
+ * console.log(result); // 4
+ */
+declare function findIndex<T>(arr: readonly T[], doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): number;
+/**
+ * Finds the index of the first item in an array that matches the given partial object.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {number} - The index of the first item that matches the partial object, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findIndex(items, { name: 'Bob' });
+ * console.log(result); // 1
+ */
+declare function findIndex<T>(arr: readonly T[], doesMatch: Partial<T>): number;
+/**
+ * Finds the index of the first item in an array that matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {number} - The index of the first item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findIndex(items, ['name', 'Alice']);
+ * console.log(result); // 0
+ */
+declare function findIndex<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown]): number;
+/**
+ * Finds the index of the first item in an array that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {number} - The index of the first item that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findIndex(items, 'name');
+ * console.log(result); // 0
+ */
+declare function findIndex<T>(arr: readonly T[], propertyToCheck: string): number;
+
+export { findIndex };

package/dist/compat/array/findIndex.mjs

@@ -0,0 +1,26 @@
+import { property } from '../object/property.mjs';
+import { matches } from '../predicate/matches.mjs';
+import { matchesProperty } from '../predicate/matchesProperty.mjs';
+
+function findIndex(source, doesMatch) {
+    switch (typeof doesMatch) {
+        case 'function': {
+            return source.findIndex(doesMatch);
+        }
+        case 'object': {
+            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
+                const key = doesMatch[0];
+                const value = doesMatch[1];
+                return source.findIndex(matchesProperty(key, value));
+            }
+            else {
+                return source.findIndex(matches(doesMatch));
+            }
+        }
+        case 'string': {
+            return source.findIndex(property(doesMatch));
+        }
+    }
+}
+
+export { findIndex };

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

@@ -0,0 +1,21 @@
+/**
+ * Finds the index of the first occurrence of a value in an array.
+ *
+ * This method is similar to `Array.prototype.indexOf`, but it also finds `NaN` values.
+ * It uses strict equality (`===`) to compare elements.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of the value to search for.
+ * @param {T[] | null | undefined} array - The array to search.
+ * @param {T} searchElement - The value to search for.
+ * @param {number} [fromIndex] - The index to start the search at.
+ * @returns {number} The index (zero-based) of the first occurrence of the value in the array, or `-1` if the value is not found.
+ *
+ * @example
+ * const array = [1, 2, 3, NaN];
+ * indexOf(array, 3); // => 2
+ * indexOf(array, NaN); // => 3
+ */
+declare function indexOf<T>(array: T[] | null | undefined, searchElement: T, fromIndex?: number): number;
+
+export { indexOf };

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

@@ -0,0 +1,21 @@
+/**
+ * Finds the index of the first occurrence of a value in an array.
+ *
+ * This method is similar to `Array.prototype.indexOf`, but it also finds `NaN` values.
+ * It uses strict equality (`===`) to compare elements.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of the value to search for.
+ * @param {T[] | null | undefined} array - The array to search.
+ * @param {T} searchElement - The value to search for.
+ * @param {number} [fromIndex] - The index to start the search at.
+ * @returns {number} The index (zero-based) of the first occurrence of the value in the array, or `-1` if the value is not found.
+ *
+ * @example
+ * const array = [1, 2, 3, NaN];
+ * indexOf(array, 3); // => 2
+ * indexOf(array, NaN); // => 3
+ */
+declare function indexOf<T>(array: T[] | null | undefined, searchElement: T, fromIndex?: number): number;
+
+export { indexOf };

package/dist/compat/array/indexOf.mjs

@@ -0,0 +1,20 @@
+function indexOf(array, searchElement, fromIndex) {
+    if (array == null) {
+        return -1;
+    }
+    if (Number.isNaN(searchElement)) {
+        fromIndex = fromIndex ?? 0;
+        if (fromIndex < 0) {
+            fromIndex = Math.max(0, array.length + fromIndex);
+        }
+        for (let i = fromIndex; i < array.length; i++) {
+            if (Number.isNaN(array[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    return array.indexOf(searchElement, fromIndex);
+}
+
+export { indexOf };

package/dist/compat/function/ary.d.mts

@@ -3,9 +3,10 @@
  *
  * @template F - The type of the function.
  * @param {F} func - The function to cap arguments for.
+ * @param guard
  * @param {number} n - The arity cap.
  * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
  */
-declare function ary<F extends (...args: any[]) => any>(func: F, n?: number, guard?: unknown): ((...args: any[]) => ReturnType<F>);
+declare function ary<F extends (...args: any[]) => any>(func: F, n?: number, guard?: unknown): (...args: any[]) => ReturnType<F>;
 
 export { ary };

package/dist/compat/function/ary.d.ts

@@ -3,9 +3,10 @@
  *
  * @template F - The type of the function.
  * @param {F} func - The function to cap arguments for.
+ * @param guard
  * @param {number} n - The arity cap.
  * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
  */
-declare function ary<F extends (...args: any[]) => any>(func: F, n?: number, guard?: unknown): ((...args: any[]) => ReturnType<F>);
+declare function ary<F extends (...args: any[]) => any>(func: F, n?: number, guard?: unknown): (...args: any[]) => ReturnType<F>;
 
 export { ary };

package/dist/compat/function/bind.d.mts

@@ -8,6 +8,8 @@
  * @param {(...args: any[]) => any} func  The function to bind.
  * @param {any} thisArg  The `this` binding of `func`.
  * @param {any[]} partials  The arguments to be partially applied.
+ * @param thisObj
+ * @param {...any} partialArgs
  * @returns {(...args: any[]) => any} Returns the new bound function.
  *
  * @example
@@ -23,7 +25,7 @@
  * bound('hi');
  * // => 'hi fred!'
  */
-declare function bind<F extends Function>(func: F, thisObj?: unknown, ...partialArgs: any[]): F;
+declare function bind<F extends (...args: any[]) => any>(func: F, thisObj?: unknown, ...partialArgs: any[]): F;
 declare namespace bind {
     var placeholder: typeof bindPlaceholder;
 }

package/dist/compat/function/bind.d.ts

@@ -8,6 +8,8 @@
  * @param {(...args: any[]) => any} func  The function to bind.
  * @param {any} thisArg  The `this` binding of `func`.
  * @param {any[]} partials  The arguments to be partially applied.
+ * @param thisObj
+ * @param {...any} partialArgs
  * @returns {(...args: any[]) => any} Returns the new bound function.
  *
  * @example
@@ -23,7 +25,7 @@
  * bound('hi');
  * // => 'hi fred!'
  */
-declare function bind<F extends Function>(func: F, thisObj?: unknown, ...partialArgs: any[]): F;
+declare function bind<F extends (...args: any[]) => any>(func: F, thisObj?: unknown, ...partialArgs: any[]): F;
 declare namespace bind {
     var placeholder: typeof bindPlaceholder;
 }

package/dist/compat/function/rest.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, start?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/dist/compat/function/rest.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, start?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };