es-toolkit 1.52.0-dev.2140 → 1.52.0-dev.2142

package/dist/function/partialRight.d.mts

@@ -1,4 +1,3 @@
-//#region src/function/partialRight.d.ts
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -14,7 +13,7 @@
  * const getValueFunc = partialRight(getValue);
  * console.log(getValueFunc()); // => 42
  */
-declare function partialRight<R>(func: () => R): () => R;
+export declare function partialRight<R>(func: () => R): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -32,7 +31,7 @@ declare function partialRight<R>(func: () => R): () => R;
  * const addOneFunc = partialRight(addOne, 1);
  * console.log(addOneFunc()); // => 2
  */
-declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
+export declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -49,7 +48,7 @@ declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
  * const double = partialRight(multiplyBy(2));
  * console.log(double(5)); // => 10
  */
-declare function partialRight<T1, R>(func: (arg1: T1) => R): (arg1: T1) => R;
+export declare function partialRight<T1, R>(func: (arg1: T1) => R): (arg1: T1) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -67,7 +66,7 @@ declare function partialRight<T1, R>(func: (arg1: T1) => R): (arg1: T1) => R;
  * const greetJohn = partialRight(greet, 'John');
  * console.log(greetJohn()); // => 'Hello, John!'
  */
-declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
+export declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -85,7 +84,7 @@ declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
  * const subtractFive = partialRight(subtract);
  * console.log(subtractFive(10, 5)); // => 5
  */
-declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R): (arg1: T1, arg2: T2) => R;
+export declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R): (arg1: T1, arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -105,7 +104,7 @@ declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R): (arg1
  * const concatWithHello = partialRight(concat, 'Hello', partialRight.placeholder);
  * console.log(concatWithHello(' World!')); // => 'Hello World!'
  */
-declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: Placeholder): (arg2: T2) => R;
+export declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: Placeholder): (arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -124,7 +123,7 @@ declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1:
  * const divideByTwo = partialRight(divide, 2);
  * console.log(divideByTwo(10)); // => 5
  */
-declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg2: T2): (arg1: T1) => R;
+export declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg2: T2): (arg1: T1) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -144,7 +143,7 @@ declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg2:
  * const multiplyByThreeAndFour = partialRight(multiply, 3, 4);
  * console.log(multiplyByThreeAndFour()); // => 12
  */
-declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: T2): () => R;
+export declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: T2): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -163,7 +162,7 @@ declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1:
  * const sumWithFive = partialRight(sumThree);
  * console.log(sumWithFive(1, 2, 5)); // => 8
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R): (arg1: T1, arg2: T2, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R): (arg1: T1, arg2: T2, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -185,7 +184,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const formatDateWithDay = partialRight(formatDate, 1, partialRight.placeholder, partialRight.placeholder);
  * console.log(formatDateWithDay(12, 2023)); // => '1/12/2023'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder): (arg2: T2, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder): (arg2: T2, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -206,7 +205,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const createUserFromUSA = partialRight(createUser, 'USA');
  * console.log(createUserFromUSA('John', 30)); // => 'John, 30 years old from USA'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: Placeholder): (arg1: T1, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: Placeholder): (arg1: T1, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -228,7 +227,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const logError = partialRight(logMessage, 'ERROR', partialRight.placeholder, '2023-10-01');
  * console.log(logError('Something went wrong!')); // => '[ERROR] Something went wrong! at 2023-10-01'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: Placeholder): (arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: Placeholder): (arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -248,7 +247,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const calculateAreaWithWidth = partialRight(calculateArea, 5);
  * console.log(calculateAreaWithWidth(10)); // => 50
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg3: T3): (arg1: T1, arg2: T2) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg3: T3): (arg1: T1, arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -270,7 +269,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const formatUSD = partialRight(formatCurrency, 100, partialRight.placeholder);
  * console.log(formatUSD('USD')); // => '100 USD'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -291,8 +290,8 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const createProfileFromCanada = partialRight(createProfile, 'John', partialRight.placeholder, 'Canada');
  * console.log(createProfileFromCanada(30)); // => 'John, 30 from Canada'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: T3): (arg1: T1) => R;
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: T3): (arg1: T1) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -308,7 +307,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * @param func The function to partially apply arguments to.
  * @returns Returns a new function that takes four arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -328,7 +327,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the second, third, and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: Placeholder): (arg2: T2, arg3: T3, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: Placeholder): (arg2: T2, arg3: T3, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -347,7 +346,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the first, third, and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg1: T1, arg3: T3, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg1: T1, arg3: T3, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -367,7 +366,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the third and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg3: T3, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg3: T3, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -385,7 +384,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the first, second, and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: Placeholder): (arg1: T1, arg2: T2, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: Placeholder): (arg1: T1, arg2: T2, arg4: T4) => R;
 /**
  * Creates a function that invokes `func` with the first argument, a placeholder for the second argument,
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
@@ -406,7 +405,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the second and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: Placeholder): (arg2: T2, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: Placeholder): (arg2: T2, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -425,7 +424,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the first and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: Placeholder): (arg1: T1, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: Placeholder): (arg1: T1, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -445,7 +444,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the fourth argument.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: Placeholder): (arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: Placeholder): (arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -462,7 +461,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the first, second, and third arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg4: T4): (arg1: T1, arg2: T2, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg4: T4): (arg1: T1, arg2: T2, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -482,7 +481,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the second and third arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: T4): (arg2: T2, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: T4): (arg2: T2, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -501,7 +500,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the first and third arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -521,7 +520,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the third argument.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -539,7 +538,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the first and second arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -559,7 +558,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the second argument.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: T2) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -578,7 +577,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the first argument.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -602,7 +601,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * const concatenateHelloWorld = partialRight(concatenate, 'Hello', ' ', 'World', '!');
  * console.log(concatenateHelloWorld()); // => 'Hello World!'
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -619,12 +618,11 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * const logError = partialRight(log, 'Error:');
  * logError('Something went wrong!'); // => 'Something went wrong! Error:'
  */
-declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any;
-declare namespace partialRight {
+export declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any;
+export declare namespace partialRight {
   var placeholder: typeof placeholderSymbol;
 }
 declare function partialRightImpl<F extends (...args: any[]) => any, P>(func: F, placeholder: P, ...partialArgs: any[]): (...args: any[]) => ReturnType<F>;
 declare const placeholderSymbol: unique symbol;
 type Placeholder = typeof placeholderSymbol;
-//#endregion
-export { partialRight };
+export {};

package/dist/function/partialRight.d.ts

@@ -1,4 +1,3 @@
-//#region src/function/partialRight.d.ts
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -14,7 +13,7 @@
  * const getValueFunc = partialRight(getValue);
  * console.log(getValueFunc()); // => 42
  */
-declare function partialRight<R>(func: () => R): () => R;
+export declare function partialRight<R>(func: () => R): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -32,7 +31,7 @@ declare function partialRight<R>(func: () => R): () => R;
  * const addOneFunc = partialRight(addOne, 1);
  * console.log(addOneFunc()); // => 2
  */
-declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
+export declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -49,7 +48,7 @@ declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
  * const double = partialRight(multiplyBy(2));
  * console.log(double(5)); // => 10
  */
-declare function partialRight<T1, R>(func: (arg1: T1) => R): (arg1: T1) => R;
+export declare function partialRight<T1, R>(func: (arg1: T1) => R): (arg1: T1) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -67,7 +66,7 @@ declare function partialRight<T1, R>(func: (arg1: T1) => R): (arg1: T1) => R;
  * const greetJohn = partialRight(greet, 'John');
  * console.log(greetJohn()); // => 'Hello, John!'
  */
-declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
+export declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -85,7 +84,7 @@ declare function partialRight<T1, R>(func: (arg1: T1) => R, arg1: T1): () => R;
  * const subtractFive = partialRight(subtract);
  * console.log(subtractFive(10, 5)); // => 5
  */
-declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R): (arg1: T1, arg2: T2) => R;
+export declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R): (arg1: T1, arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -105,7 +104,7 @@ declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R): (arg1
  * const concatWithHello = partialRight(concat, 'Hello', partialRight.placeholder);
  * console.log(concatWithHello(' World!')); // => 'Hello World!'
  */
-declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: Placeholder): (arg2: T2) => R;
+export declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: Placeholder): (arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -124,7 +123,7 @@ declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1:
  * const divideByTwo = partialRight(divide, 2);
  * console.log(divideByTwo(10)); // => 5
  */
-declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg2: T2): (arg1: T1) => R;
+export declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg2: T2): (arg1: T1) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -144,7 +143,7 @@ declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg2:
  * const multiplyByThreeAndFour = partialRight(multiply, 3, 4);
  * console.log(multiplyByThreeAndFour()); // => 12
  */
-declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: T2): () => R;
+export declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: T2): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -163,7 +162,7 @@ declare function partialRight<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1:
  * const sumWithFive = partialRight(sumThree);
  * console.log(sumWithFive(1, 2, 5)); // => 8
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R): (arg1: T1, arg2: T2, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R): (arg1: T1, arg2: T2, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -185,7 +184,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const formatDateWithDay = partialRight(formatDate, 1, partialRight.placeholder, partialRight.placeholder);
  * console.log(formatDateWithDay(12, 2023)); // => '1/12/2023'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder): (arg2: T2, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder): (arg2: T2, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -206,7 +205,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const createUserFromUSA = partialRight(createUser, 'USA');
  * console.log(createUserFromUSA('John', 30)); // => 'John, 30 years old from USA'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: Placeholder): (arg1: T1, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: Placeholder): (arg1: T1, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -228,7 +227,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const logError = partialRight(logMessage, 'ERROR', partialRight.placeholder, '2023-10-01');
  * console.log(logError('Something went wrong!')); // => '[ERROR] Something went wrong! at 2023-10-01'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: Placeholder): (arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: Placeholder): (arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -248,7 +247,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const calculateAreaWithWidth = partialRight(calculateArea, 5);
  * console.log(calculateAreaWithWidth(10)); // => 50
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg3: T3): (arg1: T1, arg2: T2) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg3: T3): (arg1: T1, arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -270,7 +269,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const formatUSD = partialRight(formatCurrency, 100, partialRight.placeholder);
  * console.log(formatUSD('USD')); // => '100 USD'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -291,8 +290,8 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * const createProfileFromCanada = partialRight(createProfile, 'John', partialRight.placeholder, 'Canada');
  * console.log(createProfileFromCanada(30)); // => 'John, 30 from Canada'
  */
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: T3): (arg1: T1) => R;
-declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: T3): (arg1: T1) => R;
+export declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -308,7 +307,7 @@ declare function partialRight<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3
  * @param func The function to partially apply arguments to.
  * @returns Returns a new function that takes four arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -328,7 +327,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the second, third, and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: Placeholder): (arg2: T2, arg3: T3, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: Placeholder): (arg2: T2, arg3: T3, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -347,7 +346,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the first, third, and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg1: T1, arg3: T3, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg1: T1, arg3: T3, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -367,7 +366,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the third and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg3: T3, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg3: T3, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -385,7 +384,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the first, second, and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: Placeholder): (arg1: T1, arg2: T2, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: Placeholder): (arg1: T1, arg2: T2, arg4: T4) => R;
 /**
  * Creates a function that invokes `func` with the first argument, a placeholder for the second argument,
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
@@ -406,7 +405,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the second and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: Placeholder): (arg2: T2, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: Placeholder): (arg2: T2, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -425,7 +424,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the first and fourth arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: Placeholder): (arg1: T1, arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: Placeholder): (arg1: T1, arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -445,7 +444,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The placeholder for the fourth argument.
  * @returns Returns a new function that takes the fourth argument.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: Placeholder): (arg4: T4) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: Placeholder): (arg4: T4) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -462,7 +461,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the first, second, and third arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg4: T4): (arg1: T1, arg2: T2, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg4: T4): (arg1: T1, arg2: T2, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -482,7 +481,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the second and third arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: T4): (arg2: T2, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: T4): (arg2: T2, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -501,7 +500,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the first and third arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -521,7 +520,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the third argument.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: T3) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: T3) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -539,7 +538,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the first and second arguments.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -559,7 +558,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the second argument.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: T2) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: T2) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -578,7 +577,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * @param arg4 The fourth argument to be partially applied.
  * @returns Returns a new function that takes the first argument.
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -602,7 +601,7 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * const concatenateHelloWorld = partialRight(concatenate, 'Hello', ' ', 'World', '!');
  * console.log(concatenateHelloWorld()); // => 'Hello World!'
  */
-declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R;
+export declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R;
 /**
  * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
  *
@@ -619,12 +618,11 @@ declare function partialRight<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3
  * const logError = partialRight(log, 'Error:');
  * logError('Something went wrong!'); // => 'Something went wrong! Error:'
  */
-declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any;
-declare namespace partialRight {
+export declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any;
+export declare namespace partialRight {
   var placeholder: typeof placeholderSymbol;
 }
 declare function partialRightImpl<F extends (...args: any[]) => any, P>(func: F, placeholder: P, ...partialArgs: any[]): (...args: any[]) => ReturnType<F>;
 declare const placeholderSymbol: unique symbol;
 type Placeholder = typeof placeholderSymbol;
-//#endregion
-export { partialRight };
+export {};

package/dist/function/partialRight.js

@@ -1,4 +1,4 @@
-//#region src/function/partialRight.ts
+// src/function/partialRight.ts
 /**
 * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
 *
@@ -42,6 +42,5 @@ function partialRightImpl(func, placeholder, ...partialArgs) {
 }
 const placeholderSymbol = Symbol("partialRight.placeholder");
 partialRight.placeholder = placeholderSymbol;
-//#endregion
 exports.partialRight = partialRight;
 exports.partialRightImpl = partialRightImpl;

package/dist/function/partialRight.mjs

@@ -1,4 +1,4 @@
-//#region src/function/partialRight.ts
+// src/function/partialRight.ts
 /**
 * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
 *
@@ -42,5 +42,4 @@ function partialRightImpl(func, placeholder, ...partialArgs) {
 }
 const placeholderSymbol = Symbol("partialRight.placeholder");
 partialRight.placeholder = placeholderSymbol;
-//#endregion
 export { partialRight, partialRightImpl };

package/dist/function/rest.d.mts

@@ -1,4 +1,3 @@
-//#region src/function/rest.d.ts
 /**
  * Creates a function that transforms the arguments of the provided function `func`.
  * The transformed arguments are passed to `func` such that the arguments starting from a specified index
@@ -29,6 +28,4 @@
  * // With fewer arguments than the start index
  * console.log(transformedFn(1)); // [1, undefined, []]
  */
-declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;
-//#endregion
-export { rest };
+export declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;