es-toolkit 1.30.1 → 1.31.0-dev.1000

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

@@ -4,6 +4,7 @@
  * @template T
  * @param {ArrayLike<T> | null | undefined} 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.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that matches the predicate, or `undefined` if no match is found.
  *
  * @example
@@ -12,13 +13,14 @@
  * const result = find(items, (item) => item > 3);
  * console.log(result); // 4
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that matches the given partial object.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that matches the partial object, or `undefined` if no match is found.
  *
  * @example
@@ -27,13 +29,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item:
  * const result = find(items, { name: 'Bob' });
  * console.log(result); // { id: 2, name: 'Bob' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that matches a property with a specific value.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} 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.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
  *
  * @example
@@ -42,13 +45,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partia
  * const result = find(items, ['name', 'Alice']);
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown], fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that has a specific property, where the property name is provided as a PropertyKey.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property, or `undefined` if no match is found.
  *
  * @example
@@ -57,13 +61,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty
  * const result = find(items, 'name');
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches the given predicate function.
  *
  * @template T
  * @param {T | null | undefined} 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.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that matches the predicate, or `undefined` if no match is found.
  *
  * @example
@@ -72,13 +77,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck:
  * const result = find(obj, (item) => item > 2);
  * console.log(result); // 3
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches the given partial value.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that matches the partial value, or `undefined` if no match is found.
  *
  * @example
@@ -87,13 +93,14 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(obj, { name: 'Bob' });
  * console.log(result); // { id: 2, name: 'Bob' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches a property with a specific value.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {[keyof T[keyof T], unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
  *
  * @example
@@ -102,13 +109,14 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(items, ['name', 'Alice']);
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown], fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that has a specific property, where the property name is provided as a PropertyKey.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that has the specified property, or `undefined` if no match is found.
  *
  * @example
@@ -117,6 +125,6 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(obj, 'name');
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
 
 export { find };

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

@@ -4,6 +4,7 @@
  * @template T
  * @param {ArrayLike<T> | null | undefined} 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.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that matches the predicate, or `undefined` if no match is found.
  *
  * @example
@@ -12,13 +13,14 @@
  * const result = find(items, (item) => item > 3);
  * console.log(result); // 4
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item: T, index: number, arr: readonly T[]) => unknown, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that matches the given partial object.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that matches the partial object, or `undefined` if no match is found.
  *
  * @example
@@ -27,13 +29,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: (item:
  * const result = find(items, { name: 'Bob' });
  * console.log(result); // { id: 2, name: 'Bob' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that matches a property with a specific value.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} 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.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
  *
  * @example
@@ -42,13 +45,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partia
  * const result = find(items, ['name', 'Alice']);
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown], fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an array that has a specific property, where the property name is provided as a PropertyKey.
  *
  * @template T
  * @param {ArrayLike<T> | null | undefined} arr - The array to search through.
  * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property, or `undefined` if no match is found.
  *
  * @example
@@ -57,13 +61,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty
  * const result = find(items, 'name');
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): T | undefined;
+declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches the given predicate function.
  *
  * @template T
  * @param {T | null | undefined} 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.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that matches the predicate, or `undefined` if no match is found.
  *
  * @example
@@ -72,13 +77,14 @@ declare function find<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck:
  * const result = find(obj, (item) => item > 2);
  * console.log(result); // 3
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches the given partial value.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that matches the partial value, or `undefined` if no match is found.
  *
  * @example
@@ -87,13 +93,14 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(obj, { name: 'Bob' });
  * console.log(result); // { id: 2, name: 'Bob' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>, fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that matches a property with a specific value.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {[keyof T[keyof T], unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first item that has the specified property value, or `undefined` if no match is found.
  *
  * @example
@@ -102,13 +109,14 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(items, ['name', 'Alice']);
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown], fromIndex?: number): T | undefined;
 /**
  * Finds the first item in an object that has a specific property, where the property name is provided as a PropertyKey.
  *
  * @template T
  * @param {T | null | undefined} object - The object to search through.
  * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0.
  * @returns {T | undefined} - The first property value that has the specified property, or `undefined` if no match is found.
  *
  * @example
@@ -117,6 +125,6 @@ declare function find<T extends Record<string, unknown>>(object: T | null | unde
  * const result = find(obj, 'name');
  * console.log(result); // { id: 1, name: 'Alice' }
  */
-declare function find<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey, fromIndex?: number): T | undefined;
 
 export { find };

package/dist/compat/array/find.mjs

@@ -2,11 +2,14 @@ import { property } from '../object/property.mjs';
 import { matches } from '../predicate/matches.mjs';
 import { matchesProperty } from '../predicate/matchesProperty.mjs';
 
-function find(source, doesMatch) {
+function find(source, doesMatch, fromIndex = 0) {
     if (!source) {
         return undefined;
     }
-    const values = Array.isArray(source) ? source : Object.values(source);
+    if (fromIndex < 0) {
+        fromIndex = Math.max(source.length + fromIndex, 0);
+    }
+    const values = Array.isArray(source) ? source.slice(fromIndex) : Object.values(source).slice(fromIndex);
     switch (typeof doesMatch) {
         case 'function': {
             if (!Array.isArray(source)) {

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

@@ -14,6 +14,6 @@
  * pull(numbers, [2, 4]);
  * console.log(numbers); // [1, 3, 5]
  */
-declare function pull<T>(arr: T[], ...valuesToRemove: readonly unknown[][]): T[];
+declare function pull<T>(arr: T[], ...valuesToRemove: readonly unknown[]): T[];
 
 export { pull };

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

@@ -14,6 +14,6 @@
  * pull(numbers, [2, 4]);
  * console.log(numbers); // [1, 3, 5]
  */
-declare function pull<T>(arr: T[], ...valuesToRemove: readonly unknown[][]): T[];
+declare function pull<T>(arr: T[], ...valuesToRemove: readonly unknown[]): T[];
 
 export { pull };

package/dist/compat/array/pull.mjs

@@ -1,8 +1,7 @@
-import { flatten } from './flatten.mjs';
 import { pull as pull$1 } from '../../array/pull.mjs';
 
 function pull(arr, ...valuesToRemove) {
-    return pull$1(arr, flatten(valuesToRemove));
+    return pull$1(arr, valuesToRemove);
 }
 
 export { pull };

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

@@ -0,0 +1,19 @@
+/**
+ * Removes all specified values from an array.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `difference`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+ * @returns {T[]} The modified array with the specified values removed.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5, 2, 4];
+ * pullAll(numbers, [2, 4]);
+ * console.log(numbers); // [1, 3, 5]
+ */
+declare function pullAll<T>(arr: T[], valuesToRemove?: ArrayLike<T>): T[];
+
+export { pullAll };

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

@@ -0,0 +1,19 @@
+/**
+ * Removes all specified values from an array.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `difference`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+ * @returns {T[]} The modified array with the specified values removed.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5, 2, 4];
+ * pullAll(numbers, [2, 4]);
+ * console.log(numbers); // [1, 3, 5]
+ */
+declare function pullAll<T>(arr: T[], valuesToRemove?: ArrayLike<T>): T[];
+
+export { pullAll };

package/dist/compat/array/pullAll.mjs

@@ -0,0 +1,7 @@
+import { pull } from '../../array/pull.mjs';
+
+function pullAll(arr, valuesToRemove = []) {
+    return pull(arr, Array.from(valuesToRemove));
+}
+
+export { pullAll };

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

@@ -0,0 +1,50 @@
+/**
+ * Removes elements from an array based on a predicate function.
+ *
+ * @param {ArrayLike<T>} arr - The array to iterate over.
+ * @param {(value: T, index: number, arr: ArrayLike<T>) => boolean} shouldRemoveElement - The function invoked per iteration.
+ * @returns {T[]} - Returns the modified array with the specified elements removed.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * remove(array, value => value % 2 === 0); // => [1, 3]
+ */
+declare function remove<T>(arr: ArrayLike<T>, shouldRemoveElement: (value: T, index: number, arr: ArrayLike<T>) => boolean): T[];
+/**
+ * Removes elements from an array based on a partial object match.
+ *
+ * @param {ArrayLike<T>} arr - The array to iterate over.
+ * @param {Partial<T>} shouldRemoveElement - The partial object to match against each element.
+ * @returns {T[]} - Returns the modified array with the specified elements removed.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * remove(objects, { a: 1 }); // => [{ a: 2 }, { a: 3 }]
+ */
+declare function remove<T>(arr: ArrayLike<T>, shouldRemoveElement: Partial<T>): T[];
+/**
+ * Removes elements from an array based on a property-value pair match.
+ *
+ * @param {ArrayLike<T>} arr - The array to iterate over.
+ * @param {[keyof T, unknown]} shouldRemoveElement - The property-value pair to match against each element.
+ * @returns {T[]} - Returns the modified array with the specified elements removed.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * remove(objects, ['a', 1]); // => [{ a: 2 }, { a: 3 }]
+ */
+declare function remove<T>(arr: ArrayLike<T>, shouldRemoveElement: [keyof T, unknown]): T[];
+/**
+ * Removes elements from an array based on a property key.
+ *
+ * @param {ArrayLike<T>} arr - The array to iterate over.
+ * @param {keyof T} shouldRemoveElement - The key of the property to match against each element.
+ * @returns {T[]} - Returns the modified array with the specified elements removed.
+ *
+ * @example
+ * const objects = [{ a: 0 }, { a: 1 }];
+ * remove(objects, 'a'); // => [{ a: 0 }]
+ */
+declare function remove<T, K extends keyof T>(arr: ArrayLike<T>, shouldRemoveElement: K): T[];
+
+export { remove };

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

@@ -0,0 +1,50 @@
+/**
+ * Removes elements from an array based on a predicate function.
+ *
+ * @param {ArrayLike<T>} arr - The array to iterate over.
+ * @param {(value: T, index: number, arr: ArrayLike<T>) => boolean} shouldRemoveElement - The function invoked per iteration.
+ * @returns {T[]} - Returns the modified array with the specified elements removed.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * remove(array, value => value % 2 === 0); // => [1, 3]
+ */
+declare function remove<T>(arr: ArrayLike<T>, shouldRemoveElement: (value: T, index: number, arr: ArrayLike<T>) => boolean): T[];
+/**
+ * Removes elements from an array based on a partial object match.
+ *
+ * @param {ArrayLike<T>} arr - The array to iterate over.
+ * @param {Partial<T>} shouldRemoveElement - The partial object to match against each element.
+ * @returns {T[]} - Returns the modified array with the specified elements removed.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * remove(objects, { a: 1 }); // => [{ a: 2 }, { a: 3 }]
+ */
+declare function remove<T>(arr: ArrayLike<T>, shouldRemoveElement: Partial<T>): T[];
+/**
+ * Removes elements from an array based on a property-value pair match.
+ *
+ * @param {ArrayLike<T>} arr - The array to iterate over.
+ * @param {[keyof T, unknown]} shouldRemoveElement - The property-value pair to match against each element.
+ * @returns {T[]} - Returns the modified array with the specified elements removed.
+ *
+ * @example
+ * const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+ * remove(objects, ['a', 1]); // => [{ a: 2 }, { a: 3 }]
+ */
+declare function remove<T>(arr: ArrayLike<T>, shouldRemoveElement: [keyof T, unknown]): T[];
+/**
+ * Removes elements from an array based on a property key.
+ *
+ * @param {ArrayLike<T>} arr - The array to iterate over.
+ * @param {keyof T} shouldRemoveElement - The key of the property to match against each element.
+ * @returns {T[]} - Returns the modified array with the specified elements removed.
+ *
+ * @example
+ * const objects = [{ a: 0 }, { a: 1 }];
+ * remove(objects, 'a'); // => [{ a: 0 }]
+ */
+declare function remove<T, K extends keyof T>(arr: ArrayLike<T>, shouldRemoveElement: K): T[];
+
+export { remove };

package/dist/compat/array/remove.mjs

@@ -0,0 +1,8 @@
+import { remove as remove$1 } from '../../array/remove.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function remove(arr, shouldRemoveElement) {
+    return remove$1(arr, iteratee(shouldRemoveElement));
+}
+
+export { remove };

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

@@ -0,0 +1,24 @@
+/**
+ * Reverses the elements of an array in place.
+ *
+ * This function takes an array and reverses its elements in place, modifying the original array.
+ * If the input is `null` or `undefined`, it returns the input as is.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[] | null | undefined} array - The array to reverse. If `null` or `undefined`, the input is returned as is.
+ * @returns {T[] | null | undefined} The reversed array, or `null`/`undefined` if the input was `null`/`undefined`.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const reversedArray = reverse(array);
+ * // reversedArray is [5, 4, 3, 2, 1], and array is also modified to [5, 4, 3, 2, 1].
+ *
+ * const emptyArray = reverse([]);
+ * // emptyArray is [].
+ *
+ * const nullArray = reverse(null);
+ * // nullArray is null.
+ */
+declare function reverse<T>(array: T[] | null | undefined): T[] | null | undefined;
+
+export { reverse };

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

@@ -0,0 +1,24 @@
+/**
+ * Reverses the elements of an array in place.
+ *
+ * This function takes an array and reverses its elements in place, modifying the original array.
+ * If the input is `null` or `undefined`, it returns the input as is.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[] | null | undefined} array - The array to reverse. If `null` or `undefined`, the input is returned as is.
+ * @returns {T[] | null | undefined} The reversed array, or `null`/`undefined` if the input was `null`/`undefined`.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const reversedArray = reverse(array);
+ * // reversedArray is [5, 4, 3, 2, 1], and array is also modified to [5, 4, 3, 2, 1].
+ *
+ * const emptyArray = reverse([]);
+ * // emptyArray is [].
+ *
+ * const nullArray = reverse(null);
+ * // nullArray is null.
+ */
+declare function reverse<T>(array: T[] | null | undefined): T[] | null | undefined;
+
+export { reverse };

package/dist/compat/array/reverse.mjs

@@ -0,0 +1,8 @@
+function reverse(array) {
+    if (array == null) {
+        return array;
+    }
+    return array.reverse();
+}
+
+export { reverse };

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

@@ -0,0 +1,16 @@
+/**
+ * Creates a function that negates the result of the predicate function.
+ *
+ * @template F - The type of the function to negate.
+ * @param {F} func - The function to negate.
+ * @returns {F} The new negated function, which negates the boolean result of `func`.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5, 6];
+ * const isEven = (n: number) => n % 2 === 0;
+ * const result = array.filter(negate(isEven));
+ * // result will be [1, 3, 5]
+ */
+declare function negate<F extends (...args: any[]) => boolean>(func: F): F;
+
+export { negate };

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

@@ -0,0 +1,16 @@
+/**
+ * Creates a function that negates the result of the predicate function.
+ *
+ * @template F - The type of the function to negate.
+ * @param {F} func - The function to negate.
+ * @returns {F} The new negated function, which negates the boolean result of `func`.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5, 6];
+ * const isEven = (n: number) => n % 2 === 0;
+ * const result = array.filter(negate(isEven));
+ * // result will be [1, 3, 5]
+ */
+declare function negate<F extends (...args: any[]) => boolean>(func: F): F;
+
+export { negate };

package/dist/compat/function/negate.mjs

@@ -0,0 +1,10 @@
+function negate(func) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    return function (...args) {
+        return !func.apply(this, args);
+    };
+}
+
+export { negate };