es-toolkit 1.47.0-dev.1840 → 1.47.0-dev.1842

package/dist/compat/array/difference.mjs

@@ -6,12 +6,12 @@ import { isArrayLikeObject } from "../predicate/isArrayLikeObject.mjs";
 * Computes the difference between an array and multiple arrays.
 *
 * @template T
-* @param {ArrayLike<T> | undefined | null} arr - The primary array from which to derive the difference. This is the main array
+* @param arr - The primary array from which to derive the difference. This is the main array
 * from which elements will be compared and filtered.
-* @param {Array<ArrayLike<T>>} values - Multiple arrays containing elements to be excluded from the primary array.
+* @param values - Multiple arrays containing elements to be excluded from the primary array.
 * These arrays will be flattened into a single array, and each element in this array will be checked against the primary array.
 * If a match is found, that element will be excluded from the result.
-* @returns {T[]} A new array containing the elements that are present in the primary array but not
+* @returns A new array containing the elements that are present in the primary array but not
 * in the flattened array.
 *
 * @example

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

@@ -5,10 +5,10 @@ import { ValueIteratee } from "../_internal/ValueIteratee.mjs";
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values The values to exclude
- * @param {ValueIteratee<T1 | T2>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values The values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor)
  * // => [1.2]
@@ -18,11 +18,11 @@ declare function differenceBy<T1, T2>(array: ArrayLike<T1> | null | undefined, v
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ValueIteratee<T1 | T2 | T3>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2], [2.3], [1.4], Math.floor)
  * // => []
@@ -32,12 +32,12 @@ declare function differenceBy<T1, T2, T3>(array: ArrayLike<T1> | null | undefine
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3, T4
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ArrayLike<T4>} values3 The third array of values to exclude
- * @param {ValueIteratee<T1 | T2 | T3 | T4>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param values3 The third array of values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2, 3.5], [2.3], [1.4], [3.2], Math.floor)
  * // => []
@@ -47,13 +47,13 @@ declare function differenceBy<T1, T2, T3, T4>(array: ArrayLike<T1> | null | unde
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3, T4, T5
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ArrayLike<T4>} values3 The third array of values to exclude
- * @param {ArrayLike<T5>} values4 The fourth array of values to exclude
- * @param {ValueIteratee<T1 | T2 | T3 | T4 | T5>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param values3 The third array of values to exclude
+ * @param values4 The fourth array of values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2, 3.5, 4.8], [2.3], [1.4], [3.2], [4.1], Math.floor)
  * // => []
@@ -63,14 +63,14 @@ declare function differenceBy<T1, T2, T3, T4, T5>(array: ArrayLike<T1> | null |
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3, T4, T5, T6
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ArrayLike<T4>} values3 The third array of values to exclude
- * @param {ArrayLike<T5>} values4 The fourth array of values to exclude
- * @param {ArrayLike<T6>} values5 The fifth array of values to exclude
- * @param {ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param values3 The third array of values to exclude
+ * @param values4 The fourth array of values to exclude
+ * @param values5 The fifth array of values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2, 3.5, 4.8, 5.3], [2.3], [1.4], [3.2], [4.1], [5.8], Math.floor)
  * // => []
@@ -80,14 +80,14 @@ declare function differenceBy<T1, T2, T3, T4, T5, T6>(array: ArrayLike<T1> | nul
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3, T4, T5, T6, T7
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ArrayLike<T4>} values3 The third array of values to exclude
- * @param {ArrayLike<T5>} values4 The fourth array of values to exclude
- * @param {ArrayLike<T6>} values5 The fifth array of values to exclude
- * @param {...(ArrayLike<T7> | ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>)[]} values Additional arrays of values to exclude and iteratee
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param values3 The third array of values to exclude
+ * @param values4 The fourth array of values to exclude
+ * @param values5 The fifth array of values to exclude
+ * @param values Additional arrays of values to exclude and iteratee
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2, 3.5, 4.8, 5.3, 6.7], [2.3], [1.4], [3.2], [4.1], [5.8], [6.2], Math.floor)
  * // => []
@@ -97,9 +97,9 @@ declare function differenceBy<T1, T2, T3, T4, T5, T6, T7>(array: ArrayLike<T1> |
  * Creates an array of array values not included in the other given arrays.
  *
  * @template T
- * @param {ArrayLike<T> | null | undefined} array The array to inspect
- * @param {...Array<ArrayLike<T>>} values The arrays of values to exclude
- * @returns {T[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values The arrays of values to exclude
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2, 1], [2, 3])
  * // => [1]

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

@@ -5,10 +5,10 @@ import { ValueIteratee } from "../_internal/ValueIteratee.js";
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values The values to exclude
- * @param {ValueIteratee<T1 | T2>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values The values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor)
  * // => [1.2]
@@ -18,11 +18,11 @@ declare function differenceBy<T1, T2>(array: ArrayLike<T1> | null | undefined, v
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ValueIteratee<T1 | T2 | T3>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2], [2.3], [1.4], Math.floor)
  * // => []
@@ -32,12 +32,12 @@ declare function differenceBy<T1, T2, T3>(array: ArrayLike<T1> | null | undefine
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3, T4
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ArrayLike<T4>} values3 The third array of values to exclude
- * @param {ValueIteratee<T1 | T2 | T3 | T4>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param values3 The third array of values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2, 3.5], [2.3], [1.4], [3.2], Math.floor)
  * // => []
@@ -47,13 +47,13 @@ declare function differenceBy<T1, T2, T3, T4>(array: ArrayLike<T1> | null | unde
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3, T4, T5
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ArrayLike<T4>} values3 The third array of values to exclude
- * @param {ArrayLike<T5>} values4 The fourth array of values to exclude
- * @param {ValueIteratee<T1 | T2 | T3 | T4 | T5>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param values3 The third array of values to exclude
+ * @param values4 The fourth array of values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2, 3.5, 4.8], [2.3], [1.4], [3.2], [4.1], Math.floor)
  * // => []
@@ -63,14 +63,14 @@ declare function differenceBy<T1, T2, T3, T4, T5>(array: ArrayLike<T1> | null |
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3, T4, T5, T6
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ArrayLike<T4>} values3 The third array of values to exclude
- * @param {ArrayLike<T5>} values4 The fourth array of values to exclude
- * @param {ArrayLike<T6>} values5 The fifth array of values to exclude
- * @param {ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6>} iteratee The iteratee invoked per element
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param values3 The third array of values to exclude
+ * @param values4 The fourth array of values to exclude
+ * @param values5 The fifth array of values to exclude
+ * @param iteratee The iteratee invoked per element
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2, 3.5, 4.8, 5.3], [2.3], [1.4], [3.2], [4.1], [5.8], Math.floor)
  * // => []
@@ -80,14 +80,14 @@ declare function differenceBy<T1, T2, T3, T4, T5, T6>(array: ArrayLike<T1> | nul
  * Creates an array of array values not included in the other given arrays using an iteratee function.
  *
  * @template T1, T2, T3, T4, T5, T6, T7
- * @param {ArrayLike<T1> | null | undefined} array The array to inspect
- * @param {ArrayLike<T2>} values1 The first array of values to exclude
- * @param {ArrayLike<T3>} values2 The second array of values to exclude
- * @param {ArrayLike<T4>} values3 The third array of values to exclude
- * @param {ArrayLike<T5>} values4 The fourth array of values to exclude
- * @param {ArrayLike<T6>} values5 The fifth array of values to exclude
- * @param {...(ArrayLike<T7> | ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>)[]} values Additional arrays of values to exclude and iteratee
- * @returns {T1[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values1 The first array of values to exclude
+ * @param values2 The second array of values to exclude
+ * @param values3 The third array of values to exclude
+ * @param values4 The fourth array of values to exclude
+ * @param values5 The fifth array of values to exclude
+ * @param values Additional arrays of values to exclude and iteratee
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2.1, 1.2, 3.5, 4.8, 5.3, 6.7], [2.3], [1.4], [3.2], [4.1], [5.8], [6.2], Math.floor)
  * // => []
@@ -97,9 +97,9 @@ declare function differenceBy<T1, T2, T3, T4, T5, T6, T7>(array: ArrayLike<T1> |
  * Creates an array of array values not included in the other given arrays.
  *
  * @template T
- * @param {ArrayLike<T> | null | undefined} array The array to inspect
- * @param {...Array<ArrayLike<T>>} values The arrays of values to exclude
- * @returns {T[]} Returns the new array of filtered values
+ * @param array The array to inspect
+ * @param values The arrays of values to exclude
+ * @returns Returns the new array of filtered values
  * @example
  * differenceBy([2, 1], [2, 3])
  * // => [1]

package/dist/compat/array/differenceBy.js

@@ -9,9 +9,9 @@ const require_flattenArrayLike = require("../_internal/flattenArrayLike.js");
 * Computes the difference between an array and multiple arrays using an iteratee function.
 *
 * @template T
-* @param {ArrayLike<T> | null | undefined} arr - The primary array from which to derive the difference.
-* @param {...any[]} values - Multiple arrays containing elements to be excluded from the primary array.
-* @returns {T[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+* @param arr - The primary array from which to derive the difference.
+* @param values - Multiple arrays containing elements to be excluded from the primary array.
+* @returns A new array containing the elements that are present in the primary array but not in the values arrays.
 */
 function differenceBy(arr, ..._values) {
 	if (!require_isArrayLikeObject.isArrayLikeObject(arr)) return [];

package/dist/compat/array/differenceBy.mjs

@@ -9,9 +9,9 @@ import { flattenArrayLike } from "../_internal/flattenArrayLike.mjs";
 * Computes the difference between an array and multiple arrays using an iteratee function.
 *
 * @template T
-* @param {ArrayLike<T> | null | undefined} arr - The primary array from which to derive the difference.
-* @param {...any[]} values - Multiple arrays containing elements to be excluded from the primary array.
-* @returns {T[]} A new array containing the elements that are present in the primary array but not in the values arrays.
+* @param arr - The primary array from which to derive the difference.
+* @param values - Multiple arrays containing elements to be excluded from the primary array.
+* @returns A new array containing the elements that are present in the primary array but not in the values arrays.
 */
 function differenceBy(arr, ..._values) {
 	if (!isArrayLikeObject(arr)) return [];

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

@@ -3,10 +3,10 @@
  * 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.
+ * @param array - The primary array to compare elements against.
+ * @param values - The array containing elements to compare with the primary array.
+ * @param comparator - A function to determine if two elements are considered equal.
+ * @returns 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 }];
@@ -21,11 +21,11 @@ declare function differenceWith<T1, T2>(array: ArrayLike<T1> | null | undefined,
  * 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.
+ * @param array - The primary array to compare elements against.
+ * @param values1 - The first array containing elements to compare with the primary array.
+ * @param values2 - The second array containing elements to compare with the primary array.
+ * @param comparator - A function to determine if two elements are considered equal.
+ * @returns 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 }];
@@ -41,11 +41,11 @@ declare function differenceWith<T1, T2, T3>(array: ArrayLike<T1> | null | undefi
  * 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
+ * @param array - The primary array to compare elements against.
+ * @param values1 - The first array containing elements to compare with the primary array.
+ * @param values2 - The second array containing elements to compare with the primary array.
+ * @param values - Additional arrays and an optional comparator function to determine if two elements are considered equal.
+ * @returns 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.
  *
@@ -75,9 +75,9 @@ declare function differenceWith<T1, T2, T3, T4>(array: ArrayLike<T1> | null | un
  * 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.
+ * @param array - The primary array to compare elements against.
+ * @param values - One or more arrays containing elements to compare with the primary array.
+ * @returns 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];

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

@@ -3,10 +3,10 @@
  * 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.
+ * @param array - The primary array to compare elements against.
+ * @param values - The array containing elements to compare with the primary array.
+ * @param comparator - A function to determine if two elements are considered equal.
+ * @returns 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 }];
@@ -21,11 +21,11 @@ declare function differenceWith<T1, T2>(array: ArrayLike<T1> | null | undefined,
  * 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.
+ * @param array - The primary array to compare elements against.
+ * @param values1 - The first array containing elements to compare with the primary array.
+ * @param values2 - The second array containing elements to compare with the primary array.
+ * @param comparator - A function to determine if two elements are considered equal.
+ * @returns 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 }];
@@ -41,11 +41,11 @@ declare function differenceWith<T1, T2, T3>(array: ArrayLike<T1> | null | undefi
  * 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
+ * @param array - The primary array to compare elements against.
+ * @param values1 - The first array containing elements to compare with the primary array.
+ * @param values2 - The second array containing elements to compare with the primary array.
+ * @param values - Additional arrays and an optional comparator function to determine if two elements are considered equal.
+ * @returns 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.
  *
@@ -75,9 +75,9 @@ declare function differenceWith<T1, T2, T3, T4>(array: ArrayLike<T1> | null | un
  * 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.
+ * @param array - The primary array to compare elements against.
+ * @param values - One or more arrays containing elements to compare with the primary array.
+ * @returns 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];

package/dist/compat/array/differenceWith.js

@@ -8,9 +8,9 @@ const require_flattenArrayLike = require("../_internal/flattenArrayLike.js");
 * Computes the difference between the primary array and one or more arrays using an optional comparator function.
 *
 * @template T
-* @param {ArrayLike<T> | null | undefined} array - The primary array to compare elements against.
-* @param {...Array<ArrayLike<unknown> | ((a: unknown, b: unknown) => boolean)>} values - One or more arrays to compare with the primary array, and an optional comparator function to determine if two elements are considered equal.
-* @returns {T[]} A new array containing the elements from the primary array that do not match any elements in the provided arrays or those compared using the comparator function.
+* @param array - The primary array to compare elements against.
+* @param values - One or more arrays to compare with the primary array, and an optional comparator function to determine if two elements are considered equal.
+* @returns A new array containing the elements from the primary array that do not match any elements in the provided arrays or those compared using the comparator function.
 *
 * @example
 * // Example with a comparator function

package/dist/compat/array/differenceWith.mjs

@@ -8,9 +8,9 @@ import { flattenArrayLike } from "../_internal/flattenArrayLike.mjs";
 * Computes the difference between the primary array and one or more arrays using an optional comparator function.
 *
 * @template T
-* @param {ArrayLike<T> | null | undefined} array - The primary array to compare elements against.
-* @param {...Array<ArrayLike<unknown> | ((a: unknown, b: unknown) => boolean)>} values - One or more arrays to compare with the primary array, and an optional comparator function to determine if two elements are considered equal.
-* @returns {T[]} A new array containing the elements from the primary array that do not match any elements in the provided arrays or those compared using the comparator function.
+* @param array - The primary array to compare elements against.
+* @param values - One or more arrays to compare with the primary array, and an optional comparator function to determine if two elements are considered equal.
+* @returns A new array containing the elements from the primary array that do not match any elements in the provided arrays or those compared using the comparator function.
 *
 * @example
 * // Example with a comparator function

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

@@ -6,10 +6,10 @@
  * of elements removed from the start.
  *
  * @template T - The type of elements in the array.
- * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
- * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
- * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
- * @returns {T[]} A new array with the specified number of elements removed from the start.
+ * @param collection - The array from which to drop elements.
+ * @param itemsCount - The number of elements to drop from the beginning of the array.
+ * @param [guard] - Enables use as an iteratee for methods like `_.map`.
+ * @returns A new array with the specified number of elements removed from the start.
  *
  * @example
  * const array = [1, 2, 3, 4, 5];

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

@@ -6,10 +6,10 @@
  * of elements removed from the start.
  *
  * @template T - The type of elements in the array.
- * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
- * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
- * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
- * @returns {T[]} A new array with the specified number of elements removed from the start.
+ * @param collection - The array from which to drop elements.
+ * @param itemsCount - The number of elements to drop from the beginning of the array.
+ * @param [guard] - Enables use as an iteratee for methods like `_.map`.
+ * @returns A new array with the specified number of elements removed from the start.
  *
  * @example
  * const array = [1, 2, 3, 4, 5];

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

@@ -6,10 +6,10 @@
  * of elements removed from the end.
  *
  * @template T - The type of elements in the array.
- * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
- * @param {number} itemsCount - The number of elements to drop from the end of the array.
- * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
- * @returns {T[]} A new array with the specified number of elements removed from the end.
+ * @param collection - The array from which to drop elements.
+ * @param itemsCount - The number of elements to drop from the end of the array.
+ * @param [guard] - Enables use as an iteratee for methods like `_.map`.
+ * @returns A new array with the specified number of elements removed from the end.
  *
  * @example
  * const array = [1, 2, 3, 4, 5];

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

@@ -6,10 +6,10 @@
  * of elements removed from the end.
  *
  * @template T - The type of elements in the array.
- * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
- * @param {number} itemsCount - The number of elements to drop from the end of the array.
- * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
- * @returns {T[]} A new array with the specified number of elements removed from the end.
+ * @param collection - The array from which to drop elements.
+ * @param itemsCount - The number of elements to drop from the end of the array.
+ * @param [guard] - Enables use as an iteratee for methods like `_.map`.
+ * @returns A new array with the specified number of elements removed from the end.
  *
  * @example
  * const array = [1, 2, 3, 4, 5];

package/dist/compat/array/dropRight.js

@@ -10,10 +10,10 @@ const require_isArrayLike = require("../predicate/isArrayLike.js");
 * of elements removed from the end.
 *
 * @template T - The type of elements in the array.
-* @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
-* @param {number} itemsCount - The number of elements to drop from the end of the array.
-* @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
-* @returns {T[]} A new array with the specified number of elements removed from the end.
+* @param collection - The array from which to drop elements.
+* @param itemsCount - The number of elements to drop from the end of the array.
+* @param [guard] - Enables use as an iteratee for methods like `_.map`.
+* @returns A new array with the specified number of elements removed from the end.
 *
 * @example
 * const array = [1, 2, 3, 4, 5];

package/dist/compat/array/dropRight.mjs

@@ -10,10 +10,10 @@ import { isArrayLike } from "../predicate/isArrayLike.mjs";
 * of elements removed from the end.
 *
 * @template T - The type of elements in the array.
-* @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
-* @param {number} itemsCount - The number of elements to drop from the end of the array.
-* @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
-* @returns {T[]} A new array with the specified number of elements removed from the end.
+* @param collection - The array from which to drop elements.
+* @param itemsCount - The number of elements to drop from the end of the array.
+* @param [guard] - Enables use as an iteratee for methods like `_.map`.
+* @returns A new array with the specified number of elements removed from the end.
 *
 * @example
 * const array = [1, 2, 3, 4, 5];

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

@@ -6,9 +6,9 @@ import { ListIteratee } from "../_internal/ListIteratee.mjs";
  * The predicate is invoked with three arguments: (value, index, array).
  *
  * @template T - The type of elements in the array.
- * @param {ArrayLike<T> | null | undefined} array - The array to query.
- * @param {ListIteratee<T>} [predicate] - The function invoked per iteration.
- * @returns {T[]} Returns the slice of array.
+ * @param array - The array to query.
+ * @param [predicate] - The function invoked per iteration.
+ * @returns Returns the slice of array.
  * @example
  *
  * const users = [

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

@@ -6,9 +6,9 @@ import { ListIteratee } from "../_internal/ListIteratee.js";
  * The predicate is invoked with three arguments: (value, index, array).
  *
  * @template T - The type of elements in the array.
- * @param {ArrayLike<T> | null | undefined} array - The array to query.
- * @param {ListIteratee<T>} [predicate] - The function invoked per iteration.
- * @returns {T[]} Returns the slice of array.
+ * @param array - The array to query.
+ * @param [predicate] - The function invoked per iteration.
+ * @returns Returns the slice of array.
  * @example
  *
  * const users = [

package/dist/compat/array/dropRightWhile.js

@@ -12,11 +12,11 @@ const require_matchesProperty = require("../predicate/matchesProperty.js");
 * predicate function returns false. It then returns a new array with the remaining elements.
 *
 * @template T - The type of elements in the array.
-* @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
-* @param {(item: T, index: number, arr: T[]) => unknown} predicate - A predicate function that determines
+* @param arr - The array from which to drop elements.
+* @param predicate - A predicate function that determines
 * whether to continue dropping elements. The function is called with each element, index, and array, and dropping
 * continues as long as it returns true.
-* @returns {T[]} A new array with the elements remaining after the predicate returns false.
+* @returns A new array with the elements remaining after the predicate returns false.
 *
 * @example
 * const array = [3, 2, 1];

package/dist/compat/array/dropRightWhile.mjs

@@ -12,11 +12,11 @@ import { matchesProperty } from "../predicate/matchesProperty.mjs";
 * predicate function returns false. It then returns a new array with the remaining elements.
 *
 * @template T - The type of elements in the array.
-* @param {ArrayLike<T> | null | undefined} arr - The array from which to drop elements.
-* @param {(item: T, index: number, arr: T[]) => unknown} predicate - A predicate function that determines
+* @param arr - The array from which to drop elements.
+* @param predicate - A predicate function that determines
 * whether to continue dropping elements. The function is called with each element, index, and array, and dropping
 * continues as long as it returns true.
-* @returns {T[]} A new array with the elements remaining after the predicate returns false.
+* @returns A new array with the elements remaining after the predicate returns false.
 *
 * @example
 * const array = [3, 2, 1];