es-toolkit 1.21.0-dev.681 → 1.21.0-dev.683

package/dist/compat/index.d.mts

@@ -57,6 +57,7 @@ export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
 export { flow } from '../function/flow.mjs';
+export { flowRight } from '../function/flowRight.mjs';
 export { mean } from '../math/mean.mjs';
 export { meanBy } from '../math/meanBy.mjs';
 export { randomInt } from '../math/randomInt.mjs';

package/dist/compat/index.d.ts

@@ -57,6 +57,7 @@ export { unary } from '../function/unary.js';
 export { partial } from '../function/partial.js';
 export { partialRight } from '../function/partialRight.js';
 export { flow } from '../function/flow.js';
+export { flowRight } from '../function/flowRight.js';
 export { mean } from '../math/mean.js';
 export { meanBy } from '../math/meanBy.js';
 export { randomInt } from '../math/randomInt.js';

package/dist/compat/index.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const zipWith = require('../_chunk/zipWith-EOU_KZ.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
-const flow = require('../_chunk/flow-Au34h2.js');
+const flowRight = require('../_chunk/flowRight-BzdOZX.js');
 const range = require('../_chunk/range-BXlMmn.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 const toMerged = require('../_chunk/toMerged-2WPeoI.js');
@@ -794,7 +794,7 @@ function ary(func, n = func.length, guard) {
     if (Number.isNaN(n) || n < 0) {
         n = 0;
     }
-    return flow.ary(func, n);
+    return flowRight.ary(func, n);
 }
 
 function bind(func, thisObj, ...partialArgs) {
@@ -861,7 +861,7 @@ function rest(func, start = func.length - 1) {
     if (Number.isNaN(start) || start < 0) {
         start = func.length - 1;
     }
-    return flow.rest(func, start);
+    return flowRight.rest(func, start);
 }
 
 function spread(func, argsIndex = 0) {
@@ -969,7 +969,7 @@ function debounce(func, debounceMs = 0, options = {}) {
     }
     let result = undefined;
     let pendingAt = null;
-    const _debounced = flow.debounce(function (...args) {
+    const _debounced = flowRight.debounce(function (...args) {
         result = func.apply(this, args);
         pendingAt = null;
     }, debounceMs, { signal, edges });
@@ -1281,7 +1281,7 @@ function mergeWithDeep(target, source, merge, stack) {
 }
 
 function merge(object, ...sources) {
-    return mergeWith(object, ...sources, flow.noop);
+    return mergeWith(object, ...sources, flowRight.noop);
 }
 
 function isArrayLike(value) {
@@ -1771,16 +1771,17 @@ exports.TimeoutError = promise_index.TimeoutError;
 exports.delay = promise_index.delay;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
-exports.after = flow.after;
-exports.before = flow.before;
-exports.flow = flow.flow;
-exports.memoize = flow.memoize;
-exports.negate = flow.negate;
-exports.noop = flow.noop;
-exports.once = flow.once;
-exports.partial = flow.partial;
-exports.partialRight = flow.partialRight;
-exports.unary = flow.unary;
+exports.after = flowRight.after;
+exports.before = flowRight.before;
+exports.flow = flowRight.flow;
+exports.flowRight = flowRight.flowRight;
+exports.memoize = flowRight.memoize;
+exports.negate = flowRight.negate;
+exports.noop = flowRight.noop;
+exports.once = flowRight.once;
+exports.partial = flowRight.partial;
+exports.partialRight = flowRight.partialRight;
+exports.unary = flowRight.unary;
 exports.mean = range.mean;
 exports.meanBy = range.meanBy;
 exports.range = range.range;

package/dist/compat/index.mjs

@@ -57,6 +57,7 @@ export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
 export { flow } from '../function/flow.mjs';
+export { flowRight } from '../function/flowRight.mjs';
 export { mean } from '../math/mean.mjs';
 export { meanBy } from '../math/meanBy.mjs';
 export { randomInt } from '../math/randomInt.mjs';

package/dist/function/flow.d.mts

@@ -1,5 +1,7 @@
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {() => R} f The function to invoke.
  * @returns {() => R} Returns the new composite function.
@@ -14,7 +16,9 @@
  */
 declare function flow<R>(f: () => R): () => R;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R} f1 The function to invoke.
  * @returns {(...args: A) => R} Returns the new composite function.
@@ -29,7 +33,9 @@ declare function flow<R>(f: () => R): () => R;
  */
 declare function flow<A extends any[], R>(f1: (...args: A) => R): (...args: A) => R;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R1} f1 The function to invoke.
  * @param {(a: R1) => R2} f2 The function to invoke.
@@ -44,7 +50,9 @@ declare function flow<A extends any[], R>(f1: (...args: A) => R): (...args: A) =
  */
 declare function flow<A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R1} f1 The function to invoke.
  * @param {(a: R1) => R2} f2 The function to invoke.
@@ -61,7 +69,9 @@ declare function flow<A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R
  */
 declare function flow<A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R1} f1 The function to invoke.
  * @param {(a: R1) => R2} f2 The function to invoke.
@@ -80,7 +90,9 @@ declare function flow<A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (
  */
 declare function flow<A extends any[], R1, R2, R3, R4>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R1} f1 The function to invoke.
  * @param {(a: R1) => R2} f2 The function to invoke.
@@ -101,7 +113,9 @@ declare function flow<A extends any[], R1, R2, R3, R4>(f1: (...args: A) => R1, f
  */
 declare function flow<A extends any[], R1, R2, R3, R4, R5>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {Array<(...args: any[]) => any>} funcs The functions to invoke.
  * @returns {(...args: any[]) => any} Returns the new composite function.

package/dist/function/flow.d.ts

@@ -1,5 +1,7 @@
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {() => R} f The function to invoke.
  * @returns {() => R} Returns the new composite function.
@@ -14,7 +16,9 @@
  */
 declare function flow<R>(f: () => R): () => R;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R} f1 The function to invoke.
  * @returns {(...args: A) => R} Returns the new composite function.
@@ -29,7 +33,9 @@ declare function flow<R>(f: () => R): () => R;
  */
 declare function flow<A extends any[], R>(f1: (...args: A) => R): (...args: A) => R;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R1} f1 The function to invoke.
  * @param {(a: R1) => R2} f2 The function to invoke.
@@ -44,7 +50,9 @@ declare function flow<A extends any[], R>(f1: (...args: A) => R): (...args: A) =
  */
 declare function flow<A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R1} f1 The function to invoke.
  * @param {(a: R1) => R2} f2 The function to invoke.
@@ -61,7 +69,9 @@ declare function flow<A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R
  */
 declare function flow<A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R1} f1 The function to invoke.
  * @param {(a: R1) => R2} f2 The function to invoke.
@@ -80,7 +90,9 @@ declare function flow<A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (
  */
 declare function flow<A extends any[], R1, R2, R3, R4>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {(...args: A) => R1} f1 The function to invoke.
  * @param {(a: R1) => R2} f2 The function to invoke.
@@ -101,7 +113,9 @@ declare function flow<A extends any[], R1, R2, R3, R4>(f1: (...args: A) => R1, f
  */
 declare function flow<A extends any[], R1, R2, R3, R4, R5>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5;
 /**
- * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
  *
  * @param {Array<(...args: any[]) => any>} funcs The functions to invoke.
  * @returns {(...args: any[]) => any} Returns the new composite function.

package/dist/function/flowRight.d.mts

@@ -0,0 +1,144 @@
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {() => R} f The function to invoke.
+ * @returns {() => R} Returns the new composite function.
+ *
+ * @example
+ * function noArgFunc() {
+ *   return 42;
+ * }
+ * const combined = flowRight(noArgFunc);
+ * console.log(combined()); // 42
+ */
+declare function flowRight<R>(f: () => R): () => R;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(...args: A) => R} f1 The function to invoke.
+ * @returns {(...args: A) => R} Returns the new composite function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *  return a * 2;
+ * }
+ * const combined = flowRight(oneArgFunc);
+ * console.log(combined(5)); // 10
+ */
+declare function flowRight<A extends any[], R>(f1: (...args: A) => R): (...args: A) => R;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @returns {(...args: A) => R2} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flowRight(square, add);
+ * console.log(combined(1, 2)); // 9
+ */
+declare function flowRight<A extends any[], R1, R2>(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @returns {(...args: A) => R3} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ *
+ * const combined = flowRight(double, square, add);
+ * console.log(combined(1, 2)); // 18
+ */
+declare function flowRight<A extends any[], R1, R2, R3>(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(a: R3) => R4} f4 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @returns {(...args: A) => R4} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ * const toStr = (n: number) => n.toString();
+ *
+ * const combined = flowRight(toStr, double, square, add);
+ * console.log(combined(1, 2));  // '18'
+ */
+declare function flowRight<A extends any[], R1, R2, R3, R4>(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(a: R4) => R5} f5 The function to invoke.
+ * @param {(a: R3) => R4} f4 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @returns {(...args: A) => R5} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ * const toStr = (n: number) => n.toString();
+ * const split = (s: string) => s.split('');
+ *
+ * const combined = flowRight(split, toStr, double, square, add);
+ * console.log(combined(1, 2)); // ['1', '8']
+ */
+declare function flowRight<A extends any[], R1, R2, R3, R4, R5>(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(...args: any[]) => any} funcs The functions to invoke.
+ * @returns {(...args: any[]) => any} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flowRight(square, add);
+ * console.log(combined(1, 2)); // 9
+ */
+declare function flowRight(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any;
+
+export { flowRight };

package/dist/function/flowRight.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {() => R} f The function to invoke.
+ * @returns {() => R} Returns the new composite function.
+ *
+ * @example
+ * function noArgFunc() {
+ *   return 42;
+ * }
+ * const combined = flowRight(noArgFunc);
+ * console.log(combined()); // 42
+ */
+declare function flowRight<R>(f: () => R): () => R;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(...args: A) => R} f1 The function to invoke.
+ * @returns {(...args: A) => R} Returns the new composite function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *  return a * 2;
+ * }
+ * const combined = flowRight(oneArgFunc);
+ * console.log(combined(5)); // 10
+ */
+declare function flowRight<A extends any[], R>(f1: (...args: A) => R): (...args: A) => R;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @returns {(...args: A) => R2} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flowRight(square, add);
+ * console.log(combined(1, 2)); // 9
+ */
+declare function flowRight<A extends any[], R1, R2>(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @returns {(...args: A) => R3} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ *
+ * const combined = flowRight(double, square, add);
+ * console.log(combined(1, 2)); // 18
+ */
+declare function flowRight<A extends any[], R1, R2, R3>(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(a: R3) => R4} f4 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @returns {(...args: A) => R4} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ * const toStr = (n: number) => n.toString();
+ *
+ * const combined = flowRight(toStr, double, square, add);
+ * console.log(combined(1, 2));  // '18'
+ */
+declare function flowRight<A extends any[], R1, R2, R3, R4>(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(a: R4) => R5} f5 The function to invoke.
+ * @param {(a: R3) => R4} f4 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @returns {(...args: A) => R5} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ * const toStr = (n: number) => n.toString();
+ * const split = (s: string) => s.split('');
+ *
+ * const combined = flowRight(split, toStr, double, square, add);
+ * console.log(combined(1, 2)); // ['1', '8']
+ */
+declare function flowRight<A extends any[], R1, R2, R3, R4, R5>(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5;
+/**
+ * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
+ *
+ * The `this` context of the returned function is also passed to the functions provided as parameters.
+ *
+ * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
+ *
+ * @param {(...args: any[]) => any} funcs The functions to invoke.
+ * @returns {(...args: any[]) => any} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flowRight(square, add);
+ * console.log(combined(1, 2)); // 9
+ */
+declare function flowRight(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any;
+
+export { flowRight };

package/dist/function/flowRight.mjs

@@ -0,0 +1,7 @@
+import { flow } from './flow.mjs';
+
+function flowRight(...funcs) {
+    return flow(...funcs.reverse());
+}
+
+export { flowRight };

package/dist/function/index.d.mts

@@ -14,3 +14,4 @@ export { rest } from './rest.mjs';
 export { curry } from './curry.mjs';
 export { spread } from './spread.mjs';
 export { flow } from './flow.mjs';
+export { flowRight } from './flowRight.mjs';

package/dist/function/index.d.ts

@@ -14,3 +14,4 @@ export { rest } from './rest.js';
 export { curry } from './curry.js';
 export { spread } from './spread.js';
 export { flow } from './flow.js';
+export { flowRight } from './flowRight.js';

package/dist/function/index.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const flow = require('../_chunk/flow-Au34h2.js');
+const flowRight = require('../_chunk/flowRight-BzdOZX.js');
 
 function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) {
     let pendingAt = null;
-    const debounced = flow.debounce(func, throttleMs, { signal, edges });
+    const debounced = flowRight.debounce(func, throttleMs, { signal, edges });
     const throttled = function (...args) {
         if (pendingAt == null) {
             pendingAt = Date.now();
@@ -51,19 +51,20 @@ function spread(func) {
     };
 }
 
-exports.after = flow.after;
-exports.ary = flow.ary;
-exports.before = flow.before;
-exports.debounce = flow.debounce;
-exports.flow = flow.flow;
-exports.memoize = flow.memoize;
-exports.negate = flow.negate;
-exports.noop = flow.noop;
-exports.once = flow.once;
-exports.partial = flow.partial;
-exports.partialRight = flow.partialRight;
-exports.rest = flow.rest;
-exports.unary = flow.unary;
+exports.after = flowRight.after;
+exports.ary = flowRight.ary;
+exports.before = flowRight.before;
+exports.debounce = flowRight.debounce;
+exports.flow = flowRight.flow;
+exports.flowRight = flowRight.flowRight;
+exports.memoize = flowRight.memoize;
+exports.negate = flowRight.negate;
+exports.noop = flowRight.noop;
+exports.once = flowRight.once;
+exports.partial = flowRight.partial;
+exports.partialRight = flowRight.partialRight;
+exports.rest = flowRight.rest;
+exports.unary = flowRight.unary;
 exports.curry = curry;
 exports.spread = spread;
 exports.throttle = throttle;

package/dist/function/index.mjs

@@ -14,3 +14,4 @@ export { rest } from './rest.mjs';
 export { curry } from './curry.mjs';
 export { spread } from './spread.mjs';
 export { flow } from './flow.mjs';
+export { flowRight } from './flowRight.mjs';

package/dist/index.d.mts

@@ -72,6 +72,7 @@ export { rest } from './function/rest.mjs';
 export { curry } from './function/curry.mjs';
 export { spread } from './function/spread.mjs';
 export { flow } from './function/flow.mjs';
+export { flowRight } from './function/flowRight.mjs';
 export { clamp } from './math/clamp.mjs';
 export { inRange } from './math/inRange.mjs';
 export { mean } from './math/mean.mjs';

package/dist/index.d.ts

@@ -72,6 +72,7 @@ export { rest } from './function/rest.js';
 export { curry } from './function/curry.js';
 export { spread } from './function/spread.js';
 export { flow } from './function/flow.js';
+export { flowRight } from './function/flowRight.js';
 export { clamp } from './math/clamp.js';
 export { inRange } from './math/inRange.js';
 export { mean } from './math/mean.js';