es-toolkit 1.47.0-dev.1841 → 1.47.0-dev.1843

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

@@ -6,8 +6,8 @@ type __ = Placeholder | Toolkit;
  * Creates a function that invokes the provided function with no arguments.
  *
  * @template R The return type of the function
- * @param {() => R} func The function to partially apply
- * @returns {() => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = () => 'Hello!';
@@ -20,8 +20,8 @@ declare function partialRight<R>(func: () => R): () => R;
  *
  * @template T The type of the argument
  * @template R The return type of the function
- * @param {(t1: T) => R} func The function to partially apply
- * @returns {(t1: T) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (name: string) => `Hello ${name}!`;
@@ -34,9 +34,9 @@ declare function partialRight<T, R>(func: (t1: T) => R): (t1: T) => R;
  *
  * @template T The type of the argument
  * @template R The return type of the function
- * @param {(t1: T) => R} func The function to partially apply
- * @param {T} arg1 The argument to pre-fill
- * @returns {() => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (name: string) => `Hello ${name}!`;
@@ -50,8 +50,8 @@ declare function partialRight<T, R>(func: (t1: T) => R, arg1: T): () => R;
  * @template T1 The type of the first argument
  * @template T2 The type of the second argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2) => R} func The function to partially apply
- * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string) => `${greeting} ${name}!`;
@@ -65,10 +65,10 @@ declare function partialRight<T1, T2, R>(func: (t1: T1, t2: T2) => R): (t1: T1,
  * @template T1 The type of the first argument
  * @template T2 The type of the second argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2) => R} func The function to partially apply
- * @param {T1} arg1 The argument to pre-fill
- * @param {__} plc2 The placeholder for the second argument
- * @returns {(t2: T2) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The argument to pre-fill
+ * @param plc2 The placeholder for the second argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string) => `${greeting} ${name}!`;
@@ -82,9 +82,9 @@ declare function partialRight<T1, T2, R>(func: (t1: T1, t2: T2) => R, arg1: T1,
  * @template T1 The type of the first argument
  * @template T2 The type of the second argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2) => R} func The function to partially apply
- * @param {T2} arg2 The argument to pre-fill
- * @returns {(t1: T1) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg2 The argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string) => `${greeting} ${name}!`;
@@ -98,10 +98,10 @@ declare function partialRight<T1, T2, R>(func: (t1: T1, t2: T2) => R, arg2: T2):
  * @template T1 The type of the first argument
  * @template T2 The type of the second argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {T2} arg2 The second argument to pre-fill
- * @returns {() => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param arg2 The second argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string) => `${greeting} ${name}!`;
@@ -116,8 +116,8 @@ declare function partialRight<T1, T2, R>(func: (t1: T1, t2: T2) => R, arg1: T1,
  * @template T2 The type of the second argument
  * @template T3 The type of the third argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply
- * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`;
@@ -132,11 +132,11 @@ declare function partialRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R
  * @template T2 The type of the second argument
  * @template T3 The type of the third argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {__} plc2 The placeholder for the second argument
- * @param {__} plc3 The placeholder for the third argument
- * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param plc2 The placeholder for the second argument
+ * @param plc3 The placeholder for the third argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`;
@@ -151,10 +151,10 @@ declare function partialRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R
  * @template T2 The type of the second argument
  * @template T3 The type of the third argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply
- * @param {T2} arg2 The second argument to pre-fill
- * @param {__} plc3 The placeholder for the third argument
- * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg2 The second argument to pre-fill
+ * @param plc3 The placeholder for the third argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`;
@@ -169,11 +169,11 @@ declare function partialRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R
  * @template T2 The type of the second argument
  * @template T3 The type of the third argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {T2} arg2 The second argument to pre-fill
- * @param {__} plc3 The placeholder for the third argument
- * @returns {(t3: T3) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param arg2 The second argument to pre-fill
+ * @param plc3 The placeholder for the third argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`;
@@ -188,9 +188,9 @@ declare function partialRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R
  * @template T2 The type of the second argument
  * @template T3 The type of the third argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply
- * @param {T3} arg3 The third argument to pre-fill
- * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg3 The third argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`;
@@ -205,11 +205,11 @@ declare function partialRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R
  * @template T2 The type of the second argument
  * @template T3 The type of the third argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {__} plc2 The placeholder for the second argument
- * @param {T3} arg3 The third argument to pre-fill
- * @returns {(t2: T2) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param plc2 The placeholder for the second argument
+ * @param arg3 The third argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`;
@@ -224,10 +224,10 @@ declare function partialRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R
  * @template T2 The type of the second argument
  * @template T3 The type of the third argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply
- * @param {T2} arg2 The second argument to pre-fill
- * @param {T3} arg3 The third argument to pre-fill
- * @returns {(t1: T1) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg2 The second argument to pre-fill
+ * @param arg3 The third argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`;
@@ -242,11 +242,11 @@ declare function partialRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R
  * @template T2 The type of the second argument
  * @template T3 The type of the third argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {T2} arg2 The second argument to pre-fill
- * @param {T3} arg3 The third argument to pre-fill
- * @returns {() => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param arg2 The second argument to pre-fill
+ * @param arg3 The third argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`;
@@ -262,8 +262,8 @@ declare function partialRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @returns {(t1: T1, t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -280,12 +280,12 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {__} plc2 The placeholder for the second argument
- * @param {__} plc3 The placeholder for the third argument
- * @param {__} plc4 The placeholder for the fourth argument
- * @returns {(t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param plc2 The placeholder for the second argument
+ * @param plc3 The placeholder for the third argument
+ * @param plc4 The placeholder for the fourth argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -302,11 +302,11 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T2} arg2 The second argument to pre-fill
- * @param {__} plc3 The placeholder for the third argument
- * @param {__} plc4 The placeholder for the fourth argument
- * @returns {(t1: T1, t3: T3, t4: T4) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg2 The second argument to pre-fill
+ * @param plc3 The placeholder for the third argument
+ * @param plc4 The placeholder for the fourth argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -323,12 +323,12 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {T2} arg2 The second argument to pre-fill
- * @param {__} plc3 The placeholder for the third argument
- * @param {__} plc4 The placeholder for the fourth argument
- * @returns {(t3: T3, t4: T4) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param arg2 The second argument to pre-fill
+ * @param plc3 The placeholder for the third argument
+ * @param plc4 The placeholder for the fourth argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -345,10 +345,10 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T3} arg3 The third argument to pre-fill
- * @param {__} plc4 The placeholder for the fourth argument
- * @returns {(t1: T1, t2: T2, t4: T4) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg3 The third argument to pre-fill
+ * @param plc4 The placeholder for the fourth argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -365,12 +365,12 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {__} plc2 The placeholder for the second argument
- * @param {T3} arg3 The third argument to pre-fill
- * @param {__} plc4 The placeholder for the fourth argument
- * @returns {(t2: T2, t4: T4) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param plc2 The placeholder for the second argument
+ * @param arg3 The third argument to pre-fill
+ * @param plc4 The placeholder for the fourth argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -387,11 +387,11 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T2} arg2 The second argument to pre-fill
- * @param {T3} arg3 The third argument to pre-fill
- * @param {__} plc4 The placeholder for the fourth argument
- * @returns {(t1: T1, t4: T4) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg2 The second argument to pre-fill
+ * @param arg3 The third argument to pre-fill
+ * @param plc4 The placeholder for the fourth argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -408,12 +408,12 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {T2} arg2 The second argument to pre-fill
- * @param {T3} arg3 The third argument to pre-fill
- * @param {__} plc4 The placeholder for the fourth argument
- * @returns {(t4: T4) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param arg2 The second argument to pre-fill
+ * @param arg3 The third argument to pre-fill
+ * @param plc4 The placeholder for the fourth argument
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -430,9 +430,9 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T4} arg4 The fourth argument to pre-fill
- * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg4 The fourth argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -449,12 +449,12 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {__} plc2 The placeholder for the second argument
- * @param {__} plc3 The placeholder for the third argument
- * @param {T4} arg4 The fourth argument to pre-fill
- * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param plc2 The placeholder for the second argument
+ * @param plc3 The placeholder for the third argument
+ * @param arg4 The fourth argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -471,11 +471,11 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T2} arg2 The second argument to pre-fill
- * @param {__} plc3 The placeholder for the third argument
- * @param {T4} arg4 The fourth argument to pre-fill
- * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg2 The second argument to pre-fill
+ * @param plc3 The placeholder for the third argument
+ * @param arg4 The fourth argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -492,12 +492,12 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {T2} arg2 The second argument to pre-fill
- * @param {__} plc3 The placeholder for the third argument
- * @param {T4} arg4 The fourth argument to pre-fill
- * @returns {(t3: T3) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param arg2 The second argument to pre-fill
+ * @param plc3 The placeholder for the third argument
+ * @param arg4 The fourth argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -514,10 +514,10 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T3} arg3 The third argument to pre-fill
- * @param {T4} arg4 The fourth argument to pre-fill
- * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg3 The third argument to pre-fill
+ * @param arg4 The fourth argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -534,12 +534,12 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {__} plc2 The placeholder for the second argument
- * @param {T3} arg3 The third argument to pre-fill
- * @param {T4} arg4 The fourth argument to pre-fill
- * @returns {(t2: T2) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param plc2 The placeholder for the second argument
+ * @param arg3 The third argument to pre-fill
+ * @param arg4 The fourth argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -556,11 +556,11 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T2} arg2 The second argument to pre-fill
- * @param {T3} arg3 The third argument to pre-fill
- * @param {T4} arg4 The fourth argument to pre-fill
- * @returns {(t1: T1) => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg2 The second argument to pre-fill
+ * @param arg3 The third argument to pre-fill
+ * @param arg4 The fourth argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -577,12 +577,12 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * @template T3 The type of the third argument
  * @template T4 The type of the fourth argument
  * @template R The return type of the function
- * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply
- * @param {T1} arg1 The first argument to pre-fill
- * @param {T2} arg2 The second argument to pre-fill
- * @param {T3} arg3 The third argument to pre-fill
- * @param {T4} arg4 The fourth argument to pre-fill
- * @returns {() => R} Returns the new partially applied function
+ * @param func The function to partially apply
+ * @param arg1 The first argument to pre-fill
+ * @param arg2 The second argument to pre-fill
+ * @param arg3 The third argument to pre-fill
+ * @param arg4 The fourth argument to pre-fill
+ * @returns Returns the new partially applied function
  *
  * @example
  * const format = (greeting: string, name: string, time: string, punctuation: string) =>
@@ -596,9 +596,9 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3,
  * The partialRight.placeholder value can be used as a placeholder for partially applied arguments.
  *
  * @template F The type of the function to partially apply
- * @param {F} func The function to partially apply arguments to
- * @param {...any[]} args The arguments to be partially applied
- * @returns {(...args: any[]) => ReturnType<F>} Returns the new partially applied function
+ * @param func The function to partially apply arguments to
+ * @param args The arguments to be partially applied
+ * @returns Returns the new partially applied function
  *
  * @example
  * function greet(greeting: string, name: string) {

package/dist/compat/function/partialRight.js

@@ -8,9 +8,9 @@ const require_partialRight = require("../../function/partialRight.js");
 * Note: This method doesn't set the `length` property of partially applied functions.
 *
 * @template F The type of the function to partially apply.
-* @param {F} func The function to partially apply arguments to.
-* @param {any[]} partialArgs The arguments to be partially applied.
-* @returns {(...args: any[]) => ReturnType<F>} Returns the new partially applied function.
+* @param func The function to partially apply arguments to.
+* @param partialArgs The arguments to be partially applied.
+* @returns Returns the new partially applied function.
 *
 * @example
 * function greet(greeting, name) {

package/dist/compat/function/partialRight.mjs

@@ -8,9 +8,9 @@ import { partialRightImpl } from "../../function/partialRight.mjs";
 * Note: This method doesn't set the `length` property of partially applied functions.
 *
 * @template F The type of the function to partially apply.
-* @param {F} func The function to partially apply arguments to.
-* @param {any[]} partialArgs The arguments to be partially applied.
-* @returns {(...args: any[]) => ReturnType<F>} Returns the new partially applied function.
+* @param func The function to partially apply arguments to.
+* @param partialArgs The arguments to be partially applied.
+* @returns Returns the new partially applied function.
 *
 * @example
 * function greet(greeting, name) {

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

@@ -6,9 +6,9 @@ import { Many } from "../_internal/Many.mjs";
  * where the argument value at the first index is provided as the first argument,
  * the argument value at the second index is provided as the second argument, and so on.
  *
- * @param {(...args: any[]) => any} func The function to rearrange arguments for.
- * @param {Array<number | number[]>} indices The arranged argument indices.
- * @returns {(...args: any[]) => any} Returns the new function.
+ * @param func The function to rearrange arguments for.
+ * @param indices The arranged argument indices.
+ * @returns Returns the new function.
  *
  * @example
  * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`;

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

@@ -6,9 +6,9 @@ import { Many } from "../_internal/Many.js";
  * where the argument value at the first index is provided as the first argument,
  * the argument value at the second index is provided as the second argument, and so on.
  *
- * @param {(...args: any[]) => any} func The function to rearrange arguments for.
- * @param {Array<number | number[]>} indices The arranged argument indices.
- * @returns {(...args: any[]) => any} Returns the new function.
+ * @param func The function to rearrange arguments for.
+ * @param indices The arranged argument indices.
+ * @returns Returns the new function.
  *
  * @example
  * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`;

package/dist/compat/function/rearg.js

@@ -5,9 +5,9 @@ const require_flatten = require("../array/flatten.js");
 * where the argument value at the first index is provided as the first argument,
 * the argument value at the second index is provided as the second argument, and so on.
 *
-* @param {(...args: any[]) => any} func The function to rearrange arguments for.
-* @param {Array<number | number[]>} indices The arranged argument indices.
-* @returns {(...args: any[]) => any} Returns the new function.
+* @param func The function to rearrange arguments for.
+* @param indices The arranged argument indices.
+* @returns Returns the new function.
 *
 * @example
 * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`;

package/dist/compat/function/rearg.mjs

@@ -5,9 +5,9 @@ import { flatten } from "../array/flatten.mjs";
 * where the argument value at the first index is provided as the first argument,
 * the argument value at the second index is provided as the second argument, and so on.
 *
-* @param {(...args: any[]) => any} func The function to rearrange arguments for.
-* @param {Array<number | number[]>} indices The arranged argument indices.
-* @returns {(...args: any[]) => any} Returns the new function.
+* @param func The function to rearrange arguments for.
+* @param indices The arranged argument indices.
+* @returns Returns the new function.
 *
 * @example
 * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`;

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

@@ -4,10 +4,10 @@
  * 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.
  *
- * @param {(...args: any[]) => any} func - The function whose arguments are to be transformed.
- * @param {number} [start=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ * @param func - The function whose arguments are to be transformed.
+ * @param [start=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[]) => any} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ * @returns 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.

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

@@ -4,10 +4,10 @@
  * 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.
  *
- * @param {(...args: any[]) => any} func - The function whose arguments are to be transformed.
- * @param {number} [start=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ * @param func - The function whose arguments are to be transformed.
+ * @param [start=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[]) => any} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ * @returns 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.

package/dist/compat/function/rest.js

@@ -5,10 +5,10 @@ const require_rest = require("../../function/rest.js");
 * 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.
 *
-* @param {(...args: any[]) => any} func - The function whose arguments are to be transformed.
-* @param {number} [start=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+* @param func - The function whose arguments are to be transformed.
+* @param [start=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[]) => any} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+* @returns 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.

package/dist/compat/function/rest.mjs

@@ -5,10 +5,10 @@ import { rest as rest$1 } from "../../function/rest.mjs";
 * 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.
 *
-* @param {(...args: any[]) => any} func - The function whose arguments are to be transformed.
-* @param {number} [start=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+* @param func - The function whose arguments are to be transformed.
+* @param [start=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[]) => any} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+* @returns 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.