@fedify/fedify 1.6.0-dev.809 → 1.6.0-dev.811

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/zipWith.js

@@ -0,0 +1,32 @@
+/**
+ * Combines multiple arrays into a single array using a custom combiner function.
+ *
+ * This function takes one array and a variable number of additional arrays,
+ * applying the provided combiner function to the corresponding elements of each array.
+ * If the input arrays are of different lengths, the resulting array will have the length
+ * of the longest input array, with undefined values for missing elements.
+ *
+ * @template T - The type of elements in the input arrays.
+ * @template R - The type of elements in the resulting array.
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {...Array<T[]>} rest - The additional arrays to zip together, followed by the combiner function.
+ * @param {(...items: T[]) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
+ * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const result = zipWith(arr1, arr2, (num, char) => `${num}${char}`);
+ * // result will be ['1a', '2b', '3c']
+ */
+export function zipWith(arr1, ...rest) {
+    const arrs = [arr1, ...rest.slice(0, -1)];
+    const combine = rest[rest.length - 1];
+    const maxIndex = Math.max(...arrs.map(arr => arr.length));
+    const result = Array(maxIndex);
+    for (let i = 0; i < maxIndex; i++) {
+        const elements = arrs.map(arr => arr[i]);
+        result[i] = combine(...elements);
+    }
+    return result;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/getSymbols.js

@@ -0,0 +1,3 @@
+export function getSymbols(object) {
+    return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/getTag.js

@@ -0,0 +1,13 @@
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {T} value The value to query.
+ * @returns {string} Returns the `Object.prototype.toString.call` result.
+ */
+export function getTag(value) {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return Object.prototype.toString.call(value);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/tags.js

@@ -0,0 +1,26 @@
+export const regexpTag = '[object RegExp]';
+export const stringTag = '[object String]';
+export const numberTag = '[object Number]';
+export const booleanTag = '[object Boolean]';
+export const argumentsTag = '[object Arguments]';
+export const symbolTag = '[object Symbol]';
+export const dateTag = '[object Date]';
+export const mapTag = '[object Map]';
+export const setTag = '[object Set]';
+export const arrayTag = '[object Array]';
+export const functionTag = '[object Function]';
+export const arrayBufferTag = '[object ArrayBuffer]';
+export const objectTag = '[object Object]';
+export const errorTag = '[object Error]';
+export const dataViewTag = '[object DataView]';
+export const uint8ArrayTag = '[object Uint8Array]';
+export const uint8ClampedArrayTag = '[object Uint8ClampedArray]';
+export const uint16ArrayTag = '[object Uint16Array]';
+export const uint32ArrayTag = '[object Uint32Array]';
+export const bigUint64ArrayTag = '[object BigUint64Array]';
+export const int8ArrayTag = '[object Int8Array]';
+export const int16ArrayTag = '[object Int16Array]';
+export const int32ArrayTag = '[object Int32Array]';
+export const bigInt64ArrayTag = '[object BigInt64Array]';
+export const float32ArrayTag = '[object Float32Array]';
+export const float64ArrayTag = '[object Float64Array]';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isArray.js

@@ -0,0 +1,23 @@
+/**
+ * Checks if the given value is an array.
+ *
+ * This function tests whether the provided value is an array or not.
+ * It returns `true` if the value is an array, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an array.
+ *
+ * @param {unknown} value - The value to test if it is an array.
+ * @returns {value is any[]} `true` if the value is an array, `false` otherwise.
+ *
+ * @example
+ * const value1 = [1, 2, 3];
+ * const value2 = 'abc';
+ * const value3 = () => {};
+ *
+ * console.log(isArray(value1)); // true
+ * console.log(isArray(value2)); // false
+ * console.log(isArray(value3)); // false
+ */
+export function isArray(value) {
+    return Array.isArray(value);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isObjectLike.js

@@ -0,0 +1,27 @@
+/**
+ * Checks if the given value is object-like.
+ *
+ * A value is object-like if its type is object and it is not null.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object-like value.
+ *
+ * @template T - The type of value.
+ * @param {T} value - The value to test if it is an object-like.
+ * @returns {value is object} `true` if the value is an object-like, `false` otherwise.
+ *
+ * @example
+ * const value1 = { a: 1 };
+ * const value2 = [1, 2, 3];
+ * const value3 = 'abc';
+ * const value4 = () => {};
+ * const value5 = null;
+ *
+ * console.log(isObjectLike(value1)); // true
+ * console.log(isObjectLike(value2)); // true
+ * console.log(isObjectLike(value3)); // false
+ * console.log(isObjectLike(value4)); // false
+ * console.log(isObjectLike(value5)); // false
+ */
+export function isObjectLike(value) {
+    return typeof value === 'object' && value !== null;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isPlainObject.js

@@ -0,0 +1,51 @@
+/**
+ * Checks if a given value is a plain object.
+ *
+ * A plain object is an object created by the `{}` literal, `new Object()`, or
+ * `Object.create(null)`.
+ *
+ * This function also handles objects with custom
+ * `Symbol.toStringTag` properties.
+ *
+ * `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the
+ * default string description of objects.
+ *
+ * @param {unknown} [object] - The value to check.
+ * @returns {boolean} - True if the value is a plain object, otherwise false.
+ *
+ * @example
+ * console.log(isPlainObject({})); // true
+ * console.log(isPlainObject([])); // false
+ * console.log(isPlainObject(null)); // false
+ * console.log(isPlainObject(Object.create(null))); // true
+ * console.log(isPlainObject(new Map())); // false
+ */
+export function isPlainObject(object) {
+    if (typeof object !== 'object') {
+        return false;
+    }
+    if (object == null) {
+        return false;
+    }
+    if (Object.getPrototypeOf(object) === null) {
+        return true;
+    }
+    if (Object.prototype.toString.call(object) !== '[object Object]') {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const tag = object[Symbol.toStringTag];
+        if (tag == null) {
+            return false;
+        }
+        const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
+        if (isTagReadonly) {
+            return false;
+        }
+        return object.toString() === `[object ${tag}]`;
+    }
+    let proto = object;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(object) === proto;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isSymbol.js

@@ -0,0 +1,17 @@
+/**
+ * Check whether a value is a symbol.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ * isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * isSymbol('abc');
+ * // => false
+ */
+export function isSymbol(value) {
+    return typeof value === 'symbol' || value instanceof Symbol;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/eq.js

@@ -0,0 +1,16 @@
+/**
+ * Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
+ *
+ * @param {unknown} value - The value to compare.
+ * @param {unknown} other - The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ *
+ * @example
+ * eq(1, 1); // true
+ * eq(0, -0); // true
+ * eq(NaN, NaN); // true
+ * eq('a', Object('a')); // false
+ */
+export function eq(value, other) {
+    return value === other || (Number.isNaN(value) && Number.isNaN(other));
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toFinite.js

@@ -0,0 +1,26 @@
+import { toNumber } from './toNumber.js';
+/**
+ * Converts `value` to a finite number.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {number} Returns the number.
+ *
+ * @example
+ * toNumber(3.2); // => 3.2
+ * toNumber(Number.MIN_VALUE); // => 5e-324
+ * toNumber(Infinity); // => 1.7976931348623157e+308
+ * toNumber('3.2'); // => 3.2
+ * toNumber(Symbol.iterator); // => 0
+ * toNumber(NaN); // => 0
+ */
+export function toFinite(value) {
+    if (!value) {
+        return value === 0 ? value : 0;
+    }
+    value = toNumber(value);
+    if (value === Infinity || value === -Infinity) {
+        const sign = value < 0 ? -1 : 1;
+        return sign * Number.MAX_VALUE;
+    }
+    return value === value ? value : 0;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toInteger.js

@@ -0,0 +1,23 @@
+import { toFinite } from './toFinite.js';
+/**
+ * Converts `value` to an integer.
+ *
+ * This function first converts `value` to a finite number. If the result has any decimal places,
+ * they are removed by rounding down to the nearest whole number.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {number} Returns the number.
+ *
+ * @example
+ * toInteger(3.2); // => 3
+ * toInteger(Number.MIN_VALUE); // => 0
+ * toInteger(Infinity); // => 1.7976931348623157e+308
+ * toInteger('3.2'); // => 3
+ * toInteger(Symbol.iterator); // => 0
+ * toInteger(NaN); // => 0
+ */
+export function toInteger(value) {
+    const finite = toFinite(value);
+    const remainder = finite % 1;
+    return remainder ? finite - remainder : finite;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toNumber.js

@@ -0,0 +1,23 @@
+import { isSymbol } from '../predicate/isSymbol.js';
+/**
+ * Converts `value` to a number.
+ *
+ * Unlike `Number()`, this function returns `NaN` for symbols.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {number} Returns the number.
+ *
+ * @example
+ * toNumber(3.2); // => 3.2
+ * toNumber(Number.MIN_VALUE); // => 5e-324
+ * toNumber(Infinity); // => Infinity
+ * toNumber('3.2'); // => 3.2
+ * toNumber(Symbol.iterator); // => NaN
+ * toNumber(NaN); // => NaN
+ */
+export function toNumber(value) {
+    if (isSymbol(value)) {
+        return NaN;
+    }
+    return Number(value);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/error/AbortError.js

@@ -0,0 +1,10 @@
+/**
+ * An error class representing an aborted operation.
+ * @augments Error
+ */
+export class AbortError extends Error {
+    constructor(message = 'The operation was aborted') {
+        super(message);
+        this.name = 'AbortError';
+    }
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/error/TimeoutError.js

@@ -0,0 +1,10 @@
+/**
+ * An error class representing an timeout operation.
+ * @augments Error
+ */
+export class TimeoutError extends Error {
+    constructor(message = 'The operation was timed out') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/error/index.js

@@ -0,0 +1,2 @@
+export { AbortError } from './AbortError.js';
+export { TimeoutError } from './TimeoutError.js';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/after.js

@@ -0,0 +1,40 @@
+/**
+ * Creates a function that only executes starting from the `n`-th call.
+ * The provided function will be invoked starting from the `n`-th call.
+ *
+ * This is particularly useful for scenarios involving events or asynchronous operations
+ * where an action should occur only after a certain number of invocations.
+ *
+ * @template F - The type of the function to be invoked.
+ * @param {number} n - The number of calls required for `func` to execute.
+ * @param {F} func - The function to be invoked.
+ * @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+ * - Tracks the number of calls.
+ * - Invokes `func` starting from the `n`-th call.
+ * - Returns `undefined` if fewer than `n` calls have been made.
+ * @throws {Error} - Throws an error if `n` is negative.
+ * @example
+ *
+ * const afterFn = after(3, () => {
+ *  console.log("called")
+ * });
+ *
+ * // Will not log anything.
+ * afterFn()
+ * // Will not log anything.
+ * afterFn()
+ * // Will log 'called'.
+ * afterFn()
+ */
+export function after(n, func) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`n must be a non-negative integer.`);
+    }
+    let counter = 0;
+    return (...args) => {
+        if (++counter >= n) {
+            return func(...args);
+        }
+        return undefined;
+    };
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/ary.js

@@ -0,0 +1,23 @@
+/**
+ * Creates a function that invokes func, with up to n arguments, ignoring any additional arguments.
+ *
+ * @template F - The type of the function.
+ * @param {F} func - The function to cap arguments for.
+ * @param {number} n - The arity cap.
+ * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
+ *
+ * @example
+ * function fn(a: number, b: number, c: number) {
+ *   return Array.from(arguments);
+ * }
+ *
+ * ary(fn, 0)(1, 2, 3) // []
+ * ary(fn, 1)(1, 2, 3) // [1]
+ * ary(fn, 2)(1, 2, 3) // [1, 2]
+ * ary(fn, 3)(1, 2, 3) // [1, 2, 3]
+ */
+export function ary(func, n) {
+    return function (...args) {
+        return func.apply(this, args.slice(0, n));
+    };
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/asyncNoop.js

@@ -0,0 +1,10 @@
+/**
+ * An asynchronous no-operation function that does nothing.
+ * This can be used as a placeholder or default function.
+ *
+ * @example
+ * asyncNoop(); // Does nothing
+ *
+ * @returns {Promise<void>} This function returns a Promise that resolves to undefined.
+ */
+export async function asyncNoop() { }

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/before.js

@@ -0,0 +1,40 @@
+/**
+ * Creates a function that limits the number of times the given function (`func`) can be called.
+ *
+ * @template F - The type of the function to be invoked.
+ * @param {number} n - The number of times the returned function is allowed to call `func` before stopping.
+ * - If `n` is 0, `func` will never be called.
+ * - If `n` is a positive integer, `func` will be called up to `n-1` times.
+ * @param {F} func - The function to be called with the limit applied.
+ * @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+ * - Tracks the number of calls.
+ * - Invokes `func` until the `n-1`-th call.
+ * - Returns `undefined` if the number of calls reaches or exceeds `n`, stopping further calls.
+ * @throws {Error} - Throw an error if `n` is negative.
+ * @example
+ *
+ * const beforeFn = before(3, () => {
+ *  console.log("called");
+ * })
+ *
+ * // Will log 'called'.
+ * beforeFn();
+ *
+ * // Will log 'called'.
+ * beforeFn();
+ *
+ * // Will not log anything.
+ * beforeFn();
+ */
+export function before(n, func) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error('n must be a non-negative integer.');
+    }
+    let counter = 0;
+    return (...args) => {
+        if (++counter < n) {
+            return func(...args);
+        }
+        return undefined;
+    };
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/curry.js

@@ -0,0 +1,42 @@
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curry(sum);
+ *
+ * // The parameter `a` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5);
+ */
+export function curry(func) {
+    if (func.length === 0 || func.length === 1) {
+        return func;
+    }
+    return function (arg) {
+        return makeCurry(func, func.length, [arg]);
+    };
+}
+function makeCurry(origin, argsLength, args) {
+    if (args.length === argsLength) {
+        return origin(...args);
+    }
+    else {
+        const next = function (arg) {
+            return makeCurry(origin, argsLength, [...args, arg]);
+        };
+        return next;
+    }
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/curryRight.js

@@ -0,0 +1,44 @@
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curryRight(sum);
+ *
+ * // The parameter `c` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5); // 30
+ */
+export function curryRight(func) {
+    if (func.length === 0 || func.length === 1) {
+        return func;
+    }
+    return function (arg) {
+        return makeCurryRight(func, func.length, [arg]);
+    };
+}
+function makeCurryRight(origin, argsLength, args) {
+    if (args.length === argsLength) {
+        return origin(...args);
+    }
+    else {
+        const next = function (arg) {
+            return makeCurryRight(origin, argsLength, [arg, ...args]);
+        };
+        return next;
+    }
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/debounce.js

@@ -0,0 +1,97 @@
+/**
+ * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to debounce.
+ * @param {number} debounceMs - The number of milliseconds to delay.
+ * @param {DebounceOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
+ * @returns A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ *
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const signal = controller.signal;
+ * const debouncedWithSignal = debounce(() => {
+ *  console.log('Function executed');
+ * }, 1000, { signal });
+ *
+ * debouncedWithSignal();
+ *
+ * // Will cancel the debounced function call
+ * controller.abort();
+ */
+export function debounce(func, debounceMs, { signal, edges } = {}) {
+    let pendingThis = undefined;
+    let pendingArgs = null;
+    const leading = edges != null && edges.includes('leading');
+    const trailing = edges == null || edges.includes('trailing');
+    const invoke = () => {
+        if (pendingArgs !== null) {
+            func.apply(pendingThis, pendingArgs);
+            pendingThis = undefined;
+            pendingArgs = null;
+        }
+    };
+    const onTimerEnd = () => {
+        if (trailing) {
+            invoke();
+        }
+        cancel();
+    };
+    let timeoutId = null;
+    const schedule = () => {
+        if (timeoutId != null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            timeoutId = null;
+            onTimerEnd();
+        }, debounceMs);
+    };
+    const cancelTimer = () => {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+    };
+    const cancel = () => {
+        cancelTimer();
+        pendingThis = undefined;
+        pendingArgs = null;
+    };
+    const flush = () => {
+        cancelTimer();
+        invoke();
+    };
+    const debounced = function (...args) {
+        if (signal?.aborted) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        pendingThis = this;
+        pendingArgs = args;
+        const isFirstCall = timeoutId == null;
+        schedule();
+        if (leading && isFirstCall) {
+            invoke();
+        }
+    };
+    debounced.schedule = schedule;
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    signal?.addEventListener('abort', cancel, { once: true });
+    return debounced;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/flow.js

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flow(add, square);
+ * console.log(combined(1, 2)); // 9
+ */
+export function flow(...funcs) {
+    return function (...args) {
+        let result = funcs.length ? funcs[0].apply(this, args) : args[0];
+        for (let i = 1; i < funcs.length; i++) {
+            result = funcs[i].call(this, result);
+        }
+        return result;
+    };
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/flowRight.js

@@ -0,0 +1,21 @@
+import { flow } from './flow.js';
+/**
+ * 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
+ */
+export function flowRight(...funcs) {
+    return flow(...funcs.reverse());
+}