Index: node_modules/es-toolkit/dist/function/after.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/after.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/after.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,31 @@ +/** + * 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) => ReturnType | 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() + */ +declare function after any>(n: number, func: F): (...args: Parameters) => ReturnType | undefined; + +export { after }; Index: node_modules/es-toolkit/dist/function/after.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/after.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/after.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,31 @@ +/** + * 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) => ReturnType | 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() + */ +declare function after any>(n: number, func: F): (...args: Parameters) => ReturnType | undefined; + +export { after }; Index: node_modules/es-toolkit/dist/function/after.js =================================================================== --- node_modules/es-toolkit/dist/function/after.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/after.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +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; + }; +} + +exports.after = after; Index: node_modules/es-toolkit/dist/function/after.mjs =================================================================== --- node_modules/es-toolkit/dist/function/after.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/after.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,14 @@ +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; + }; +} + +export { after }; Index: node_modules/es-toolkit/dist/function/ary.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/ary.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/ary.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +/** + * 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} 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] + */ +declare function ary any>(func: F, n: number): (...args: any[]) => ReturnType; + +export { ary }; Index: node_modules/es-toolkit/dist/function/ary.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/ary.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/ary.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +/** + * 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} 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] + */ +declare function ary any>(func: F, n: number): (...args: any[]) => ReturnType; + +export { ary }; Index: node_modules/es-toolkit/dist/function/ary.js =================================================================== --- node_modules/es-toolkit/dist/function/ary.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/ary.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function ary(func, n) { + return function (...args) { + return func.apply(this, args.slice(0, n)); + }; +} + +exports.ary = ary; Index: node_modules/es-toolkit/dist/function/ary.mjs =================================================================== --- node_modules/es-toolkit/dist/function/ary.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/ary.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +function ary(func, n) { + return function (...args) { + return func.apply(this, args.slice(0, n)); + }; +} + +export { ary }; Index: node_modules/es-toolkit/dist/function/asyncNoop.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/asyncNoop.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/asyncNoop.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +/** + * An asynchronous no-operation function that does nothing. + * This can be used as a placeholder or default function. + * + * @example + * asyncNoop(); // Does nothing + * + * @returns {Promise} This function returns a Promise that resolves to undefined. + */ +declare function asyncNoop(): Promise; + +export { asyncNoop }; Index: node_modules/es-toolkit/dist/function/asyncNoop.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/asyncNoop.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/asyncNoop.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +/** + * An asynchronous no-operation function that does nothing. + * This can be used as a placeholder or default function. + * + * @example + * asyncNoop(); // Does nothing + * + * @returns {Promise} This function returns a Promise that resolves to undefined. + */ +declare function asyncNoop(): Promise; + +export { asyncNoop }; Index: node_modules/es-toolkit/dist/function/asyncNoop.js =================================================================== --- node_modules/es-toolkit/dist/function/asyncNoop.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/asyncNoop.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +async function asyncNoop() { } + +exports.asyncNoop = asyncNoop; Index: node_modules/es-toolkit/dist/function/asyncNoop.mjs =================================================================== --- node_modules/es-toolkit/dist/function/asyncNoop.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/asyncNoop.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,3 @@ +async function asyncNoop() { } + +export { asyncNoop }; Index: node_modules/es-toolkit/dist/function/before.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/before.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/before.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,31 @@ +/** + * 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) => ReturnType | 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(); + */ +declare function before any>(n: number, func: F): (...args: Parameters) => ReturnType | undefined; + +export { before }; Index: node_modules/es-toolkit/dist/function/before.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/before.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/before.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,31 @@ +/** + * 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) => ReturnType | 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(); + */ +declare function before any>(n: number, func: F): (...args: Parameters) => ReturnType | undefined; + +export { before }; Index: node_modules/es-toolkit/dist/function/before.js =================================================================== --- node_modules/es-toolkit/dist/function/before.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/before.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +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; + }; +} + +exports.before = before; Index: node_modules/es-toolkit/dist/function/before.mjs =================================================================== --- node_modules/es-toolkit/dist/function/before.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/before.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,14 @@ +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; + }; +} + +export { before }; Index: node_modules/es-toolkit/dist/function/curry.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/curry.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/curry.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,126 @@ +/** + * 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 {() => R} func - The function to curry. + * @returns {() => R} A curried function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const curriedNoArgFunc = curry(noArgFunc); + * console.log(curriedNoArgFunc()); // 42 + */ +declare function curry(func: () => R): () => R; +/** + * 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 {(p: P) => R} func - The function to curry. + * @returns {(p: P) => R} A curried function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const curriedOneArgFunc = curry(oneArgFunc); + * console.log(curriedOneArgFunc(5)); // 10 + */ +declare function curry(func: (p: P) => R): (p: P) => R; +/** + * 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 {(p1: P1, p2: P2) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => R} A curried function. + * + * @example + * function twoArgFunc(a: number, b: number) { + * return a + b; + * } + * const curriedTwoArgFunc = curry(twoArgFunc); + * const add5 = curriedTwoArgFunc(5); + * console.log(add5(10)); // 15 + */ +declare function curry(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => R} A curried function. + * + * @example + * function threeArgFunc(a: number, b: number, c: number) { + * return a + b + c; + * } + * const curriedThreeArgFunc = curry(threeArgFunc); + * const add1 = curriedThreeArgFunc(1); + * const add3 = add1(2); + * console.log(add3(3)); // 6 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function. + * + * @example + * function fourArgFunc(a: number, b: number, c: number, d: number) { + * return a + b + c + d; + * } + * const curriedFourArgFunc = curry(fourArgFunc); + * const add1 = curriedFourArgFunc(1); + * const add3 = add1(2); + * const add6 = add3(3); + * console.log(add6(4)); // 10 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function. + * + * @example + * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) { + * return a + b + c + d + e; + * } + * const curriedFiveArgFunc = curry(fiveArgFunc); + * const add1 = curriedFiveArgFunc(1); + * const add3 = add1(2); + * const add6 = add3(3); + * const add10 = add6(4); + * console.log(add10(5)); // 15 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R; +/** + * 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); + */ +declare function curry(func: (...args: any[]) => any): (...args: any[]) => any; + +export { curry }; Index: node_modules/es-toolkit/dist/function/curry.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/curry.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/curry.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,126 @@ +/** + * 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 {() => R} func - The function to curry. + * @returns {() => R} A curried function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const curriedNoArgFunc = curry(noArgFunc); + * console.log(curriedNoArgFunc()); // 42 + */ +declare function curry(func: () => R): () => R; +/** + * 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 {(p: P) => R} func - The function to curry. + * @returns {(p: P) => R} A curried function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const curriedOneArgFunc = curry(oneArgFunc); + * console.log(curriedOneArgFunc(5)); // 10 + */ +declare function curry(func: (p: P) => R): (p: P) => R; +/** + * 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 {(p1: P1, p2: P2) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => R} A curried function. + * + * @example + * function twoArgFunc(a: number, b: number) { + * return a + b; + * } + * const curriedTwoArgFunc = curry(twoArgFunc); + * const add5 = curriedTwoArgFunc(5); + * console.log(add5(10)); // 15 + */ +declare function curry(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => R} A curried function. + * + * @example + * function threeArgFunc(a: number, b: number, c: number) { + * return a + b + c; + * } + * const curriedThreeArgFunc = curry(threeArgFunc); + * const add1 = curriedThreeArgFunc(1); + * const add3 = add1(2); + * console.log(add3(3)); // 6 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function. + * + * @example + * function fourArgFunc(a: number, b: number, c: number, d: number) { + * return a + b + c + d; + * } + * const curriedFourArgFunc = curry(fourArgFunc); + * const add1 = curriedFourArgFunc(1); + * const add3 = add1(2); + * const add6 = add3(3); + * console.log(add6(4)); // 10 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function. + * + * @example + * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) { + * return a + b + c + d + e; + * } + * const curriedFiveArgFunc = curry(fiveArgFunc); + * const add1 = curriedFiveArgFunc(1); + * const add3 = add1(2); + * const add6 = add3(3); + * const add10 = add6(4); + * console.log(add10(5)); // 15 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R; +/** + * 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); + */ +declare function curry(func: (...args: any[]) => any): (...args: any[]) => any; + +export { curry }; Index: node_modules/es-toolkit/dist/function/curry.js =================================================================== --- node_modules/es-toolkit/dist/function/curry.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/curry.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +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; + } +} + +exports.curry = curry; Index: node_modules/es-toolkit/dist/function/curry.mjs =================================================================== --- node_modules/es-toolkit/dist/function/curry.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/curry.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +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; + } +} + +export { curry }; Index: node_modules/es-toolkit/dist/function/curryRight.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/curryRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/curryRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,140 @@ +/** + * 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 {() => R} func - The function to curry. + * @returns {() => R} A curried function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const curriedNoArgFunc = curryRight(noArgFunc); + * console.log(curriedNoArgFunc()); // 42 + */ +declare function curryRight(func: () => R): () => R; +/** + * 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 {(p: P) => R} func - The function to curry. + * @returns {(p: P) => R} A curried function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const curriedOneArgFunc = curryRight(oneArgFunc); + * console.log(curriedOneArgFunc(5)); // 10 + */ +declare function curryRight(func: (p: P) => R): (p: P) => R; +/** + * 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 {(p1: P1, p2: P2) => R} func - The function to curry. + * @returns {(p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function twoArgFunc(a: number, b: number) { + * return [a, b]; + * } + * const curriedTwoArgFunc = curryRight(twoArgFunc); + * const func = curriedTwoArgFunc(1); + * console.log(func(2)); // [2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2) => R): (p2: P2) => (p1: P1) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry. + * @returns {(p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function threeArgFunc(a: number, b: number, c: number) { + * return [a, b, c]; + * } + * const curriedThreeArgFunc = curryRight(threeArgFunc); + * const func = curriedThreeArgFunc(1); + * const func2 = func(2); + * console.log(func2(3)); // [3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3) => R): (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry. + * @returns {(p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function fourArgFunc(a: number, b: number, c: number, d: number) { + * return [a, b, c, d]; + * } + * const curriedFourArgFunc = curryRight(fourArgFunc); + * const func = curriedFourArgFunc(1); + * const func2 = func(2); + * const func3 = func2(3); + * console.log(func3(4)); // [4, 3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry. + * @returns {(p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) { + * return [a, b, c, d, e]; + * } + * const curriedFiveArgFunc = curryRight(fiveArgFunc); + * const func = curriedFiveArgFunc(1); + * const func2 = func(2); + * const func3 = func2(3); + * const func4 = func3(4); + * console.log(func4(5)); // [5, 4, 3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * 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 + */ +declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any; + +export { curryRight }; Index: node_modules/es-toolkit/dist/function/curryRight.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/curryRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/curryRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,140 @@ +/** + * 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 {() => R} func - The function to curry. + * @returns {() => R} A curried function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const curriedNoArgFunc = curryRight(noArgFunc); + * console.log(curriedNoArgFunc()); // 42 + */ +declare function curryRight(func: () => R): () => R; +/** + * 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 {(p: P) => R} func - The function to curry. + * @returns {(p: P) => R} A curried function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const curriedOneArgFunc = curryRight(oneArgFunc); + * console.log(curriedOneArgFunc(5)); // 10 + */ +declare function curryRight(func: (p: P) => R): (p: P) => R; +/** + * 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 {(p1: P1, p2: P2) => R} func - The function to curry. + * @returns {(p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function twoArgFunc(a: number, b: number) { + * return [a, b]; + * } + * const curriedTwoArgFunc = curryRight(twoArgFunc); + * const func = curriedTwoArgFunc(1); + * console.log(func(2)); // [2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2) => R): (p2: P2) => (p1: P1) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry. + * @returns {(p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function threeArgFunc(a: number, b: number, c: number) { + * return [a, b, c]; + * } + * const curriedThreeArgFunc = curryRight(threeArgFunc); + * const func = curriedThreeArgFunc(1); + * const func2 = func(2); + * console.log(func2(3)); // [3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3) => R): (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry. + * @returns {(p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function fourArgFunc(a: number, b: number, c: number, d: number) { + * return [a, b, c, d]; + * } + * const curriedFourArgFunc = curryRight(fourArgFunc); + * const func = curriedFourArgFunc(1); + * const func2 = func(2); + * const func3 = func2(3); + * console.log(func3(4)); // [4, 3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * 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 {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry. + * @returns {(p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) { + * return [a, b, c, d, e]; + * } + * const curriedFiveArgFunc = curryRight(fiveArgFunc); + * const func = curriedFiveArgFunc(1); + * const func2 = func(2); + * const func3 = func2(3); + * const func4 = func3(4); + * console.log(func4(5)); // [5, 4, 3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * 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 + */ +declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any; + +export { curryRight }; Index: node_modules/es-toolkit/dist/function/curryRight.js =================================================================== --- node_modules/es-toolkit/dist/function/curryRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/curryRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +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; + } +} + +exports.curryRight = curryRight; Index: node_modules/es-toolkit/dist/function/curryRight.mjs =================================================================== --- node_modules/es-toolkit/dist/function/curryRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/curryRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +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; + } +} + +export { curryRight }; Index: node_modules/es-toolkit/dist/function/debounce.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/debounce.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/debounce.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,74 @@ +interface DebounceOptions { + /** + * An optional AbortSignal to cancel the debounced function. + */ + signal?: AbortSignal; + /** + * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both. + * If `edges` includes "leading", the function will be invoked at the start of the delay period. + * If `edges` includes "trailing", the function will be invoked at the end of the delay period. + * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period. + * @default ["trailing"] + */ + edges?: Array<'leading' | 'trailing'>; +} +interface DebouncedFunction void> { + (...args: Parameters): void; + /** + * Schedules the execution of the debounced function after the specified debounce delay. + * This method resets any existing timer, ensuring that the function is only invoked + * after the delay has elapsed since the last call to the debounced function. + * It is typically called internally whenever the debounced function is invoked. + * + * @returns {void} + */ + schedule: () => void; + /** + * Cancels any pending execution of the debounced function. + * This method clears the active timer and resets any stored context or arguments. + */ + cancel: () => void; + /** + * Immediately invokes the debounced function if there is a pending execution. + * This method executes the function right away if there is a pending execution. + */ + flush: () => void; +} +/** + * 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(); + */ +declare function debounce void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction; + +export { type DebounceOptions, type DebouncedFunction, debounce }; Index: node_modules/es-toolkit/dist/function/debounce.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/debounce.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/debounce.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,74 @@ +interface DebounceOptions { + /** + * An optional AbortSignal to cancel the debounced function. + */ + signal?: AbortSignal; + /** + * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both. + * If `edges` includes "leading", the function will be invoked at the start of the delay period. + * If `edges` includes "trailing", the function will be invoked at the end of the delay period. + * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period. + * @default ["trailing"] + */ + edges?: Array<'leading' | 'trailing'>; +} +interface DebouncedFunction void> { + (...args: Parameters): void; + /** + * Schedules the execution of the debounced function after the specified debounce delay. + * This method resets any existing timer, ensuring that the function is only invoked + * after the delay has elapsed since the last call to the debounced function. + * It is typically called internally whenever the debounced function is invoked. + * + * @returns {void} + */ + schedule: () => void; + /** + * Cancels any pending execution of the debounced function. + * This method clears the active timer and resets any stored context or arguments. + */ + cancel: () => void; + /** + * Immediately invokes the debounced function if there is a pending execution. + * This method executes the function right away if there is a pending execution. + */ + flush: () => void; +} +/** + * 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(); + */ +declare function debounce void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction; + +export { type DebounceOptions, type DebouncedFunction, debounce }; Index: node_modules/es-toolkit/dist/function/debounce.js =================================================================== --- node_modules/es-toolkit/dist/function/debounce.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/debounce.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,66 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +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 = () => { + invoke(); + }; + const debounced = function (...args) { + if (signal?.aborted) { + return; + } + 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; +} + +exports.debounce = debounce; Index: node_modules/es-toolkit/dist/function/debounce.mjs =================================================================== --- node_modules/es-toolkit/dist/function/debounce.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/debounce.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,62 @@ +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 = () => { + invoke(); + }; + const debounced = function (...args) { + if (signal?.aborted) { + return; + } + 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; +} + +export { debounce }; Index: node_modules/es-toolkit/dist/function/flow.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/flow.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/flow.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,132 @@ +/** + * 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. + * + * @example + * function noArgFunc() { + * return 42; + * } + * + * const combined = flow(noArgFunc); + * console.log(combined()); // 42 + */ +declare function flow(f: () => R): () => R; +/** + * 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. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * + * const combined = flow(oneArgFunc); + * console.log(combined(5)); // 10 + */ +declare function flow(f1: (...args: A) => R): (...args: A) => R; +/** + * 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. + * @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 = flow(add, square); + * console.log(combined(1, 2)); // 9 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2; +/** + * 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. + * @param {(a: R2) => R3} f3 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 = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3; +/** + * 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. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R3) => R4} f4 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 = flow(add, square, double, toStr); + * console.log(combined(1, 2)); // '18' + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4; +/** + * 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. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R3) => R4} f4 The function to invoke. + * @param {(a: R4) => R5} f5 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 = flow(add, square, double, toStr, split); + * console.log(combined(1, 2)); // ['1', '8'] + */ +declare function flow(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 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 + */ +declare function flow(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any; + +export { flow }; Index: node_modules/es-toolkit/dist/function/flow.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/flow.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/flow.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,132 @@ +/** + * 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. + * + * @example + * function noArgFunc() { + * return 42; + * } + * + * const combined = flow(noArgFunc); + * console.log(combined()); // 42 + */ +declare function flow(f: () => R): () => R; +/** + * 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. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * + * const combined = flow(oneArgFunc); + * console.log(combined(5)); // 10 + */ +declare function flow(f1: (...args: A) => R): (...args: A) => R; +/** + * 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. + * @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 = flow(add, square); + * console.log(combined(1, 2)); // 9 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2; +/** + * 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. + * @param {(a: R2) => R3} f3 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 = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3; +/** + * 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. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R3) => R4} f4 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 = flow(add, square, double, toStr); + * console.log(combined(1, 2)); // '18' + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4; +/** + * 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. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R3) => R4} f4 The function to invoke. + * @param {(a: R4) => R5} f5 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 = flow(add, square, double, toStr, split); + * console.log(combined(1, 2)); // ['1', '8'] + */ +declare function flow(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 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 + */ +declare function flow(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any; + +export { flow }; Index: node_modules/es-toolkit/dist/function/flow.js =================================================================== --- node_modules/es-toolkit/dist/function/flow.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/flow.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +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; + }; +} + +exports.flow = flow; Index: node_modules/es-toolkit/dist/function/flow.mjs =================================================================== --- node_modules/es-toolkit/dist/function/flow.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/flow.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +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; + }; +} + +export { flow }; Index: node_modules/es-toolkit/dist/function/flowRight.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/flowRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/flowRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -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(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(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(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(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(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(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 }; Index: node_modules/es-toolkit/dist/function/flowRight.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/flowRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/flowRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -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(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(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(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(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(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(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 }; Index: node_modules/es-toolkit/dist/function/flowRight.js =================================================================== --- node_modules/es-toolkit/dist/function/flowRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/flowRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flow = require('./flow.js'); + +function flowRight(...funcs) { + return flow.flow(...funcs.reverse()); +} + +exports.flowRight = flowRight; Index: node_modules/es-toolkit/dist/function/flowRight.mjs =================================================================== --- node_modules/es-toolkit/dist/function/flowRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/flowRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +import { flow } from './flow.mjs'; + +function flowRight(...funcs) { + return flow(...funcs.reverse()); +} + +export { flowRight }; Index: node_modules/es-toolkit/dist/function/identity.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/identity.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/identity.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,22 @@ +/** + * Returns the input value unchanged. + * + * @template T - The type of the input value. + * @param {T} x - The value to be returned. + * @returns {T} The input value. + * + * @example + * // Returns 5 + * identity(5); + * + * @example + * // Returns 'hello' + * identity('hello'); + * + * @example + * // Returns { key: 'value' } + * identity({ key: 'value' }); + */ +declare function identity(x: T): T; + +export { identity }; Index: node_modules/es-toolkit/dist/function/identity.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/identity.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/identity.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,22 @@ +/** + * Returns the input value unchanged. + * + * @template T - The type of the input value. + * @param {T} x - The value to be returned. + * @returns {T} The input value. + * + * @example + * // Returns 5 + * identity(5); + * + * @example + * // Returns 'hello' + * identity('hello'); + * + * @example + * // Returns { key: 'value' } + * identity({ key: 'value' }); + */ +declare function identity(x: T): T; + +export { identity }; Index: node_modules/es-toolkit/dist/function/identity.js =================================================================== --- node_modules/es-toolkit/dist/function/identity.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/identity.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function identity(x) { + return x; +} + +exports.identity = identity; Index: node_modules/es-toolkit/dist/function/identity.mjs =================================================================== --- node_modules/es-toolkit/dist/function/identity.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/identity.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,5 @@ +function identity(x) { + return x; +} + +export { identity }; Index: node_modules/es-toolkit/dist/function/index.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/index.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/index.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +export { after } from './after.mjs'; +export { ary } from './ary.mjs'; +export { asyncNoop } from './asyncNoop.mjs'; +export { before } from './before.mjs'; +export { curry } from './curry.mjs'; +export { curryRight } from './curryRight.mjs'; +export { DebounceOptions, DebouncedFunction, debounce } from './debounce.mjs'; +export { flow } from './flow.mjs'; +export { flowRight } from './flowRight.mjs'; +export { identity } from './identity.mjs'; +export { MemoizeCache, memoize } from './memoize.mjs'; +export { negate } from './negate.mjs'; +export { noop } from './noop.mjs'; +export { once } from './once.mjs'; +export { partial } from './partial.mjs'; +export { partialRight } from './partialRight.mjs'; +export { rest } from './rest.mjs'; +export { retry } from './retry.mjs'; +export { spread } from './spread.mjs'; +export { ThrottleOptions, ThrottledFunction, throttle } from './throttle.mjs'; +export { unary } from './unary.mjs'; Index: node_modules/es-toolkit/dist/function/index.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/index.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/index.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +export { after } from './after.js'; +export { ary } from './ary.js'; +export { asyncNoop } from './asyncNoop.js'; +export { before } from './before.js'; +export { curry } from './curry.js'; +export { curryRight } from './curryRight.js'; +export { DebounceOptions, DebouncedFunction, debounce } from './debounce.js'; +export { flow } from './flow.js'; +export { flowRight } from './flowRight.js'; +export { identity } from './identity.js'; +export { MemoizeCache, memoize } from './memoize.js'; +export { negate } from './negate.js'; +export { noop } from './noop.js'; +export { once } from './once.js'; +export { partial } from './partial.js'; +export { partialRight } from './partialRight.js'; +export { rest } from './rest.js'; +export { retry } from './retry.js'; +export { spread } from './spread.js'; +export { ThrottleOptions, ThrottledFunction, throttle } from './throttle.js'; +export { unary } from './unary.js'; Index: node_modules/es-toolkit/dist/function/index.js =================================================================== --- node_modules/es-toolkit/dist/function/index.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/index.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,49 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const after = require('./after.js'); +const ary = require('./ary.js'); +const asyncNoop = require('./asyncNoop.js'); +const before = require('./before.js'); +const curry = require('./curry.js'); +const curryRight = require('./curryRight.js'); +const debounce = require('./debounce.js'); +const flow = require('./flow.js'); +const flowRight = require('./flowRight.js'); +const identity = require('./identity.js'); +const memoize = require('./memoize.js'); +const negate = require('./negate.js'); +const noop = require('./noop.js'); +const once = require('./once.js'); +const partial = require('./partial.js'); +const partialRight = require('./partialRight.js'); +const rest = require('./rest.js'); +const retry = require('./retry.js'); +const spread = require('./spread.js'); +const throttle = require('./throttle.js'); +const unary = require('./unary.js'); + + + +exports.after = after.after; +exports.ary = ary.ary; +exports.asyncNoop = asyncNoop.asyncNoop; +exports.before = before.before; +exports.curry = curry.curry; +exports.curryRight = curryRight.curryRight; +exports.debounce = debounce.debounce; +exports.flow = flow.flow; +exports.flowRight = flowRight.flowRight; +exports.identity = identity.identity; +exports.memoize = memoize.memoize; +exports.negate = negate.negate; +exports.noop = noop.noop; +exports.once = once.once; +exports.partial = partial.partial; +exports.partialRight = partialRight.partialRight; +exports.rest = rest.rest; +exports.retry = retry.retry; +exports.spread = spread.spread; +exports.throttle = throttle.throttle; +exports.unary = unary.unary; Index: node_modules/es-toolkit/dist/function/index.mjs =================================================================== --- node_modules/es-toolkit/dist/function/index.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/index.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +export { after } from './after.mjs'; +export { ary } from './ary.mjs'; +export { asyncNoop } from './asyncNoop.mjs'; +export { before } from './before.mjs'; +export { curry } from './curry.mjs'; +export { curryRight } from './curryRight.mjs'; +export { debounce } from './debounce.mjs'; +export { flow } from './flow.mjs'; +export { flowRight } from './flowRight.mjs'; +export { identity } from './identity.mjs'; +export { memoize } from './memoize.mjs'; +export { negate } from './negate.mjs'; +export { noop } from './noop.mjs'; +export { once } from './once.mjs'; +export { partial } from './partial.mjs'; +export { partialRight } from './partialRight.mjs'; +export { rest } from './rest.mjs'; +export { retry } from './retry.mjs'; +export { spread } from './spread.mjs'; +export { throttle } from './throttle.mjs'; +export { unary } from './unary.mjs'; Index: node_modules/es-toolkit/dist/function/memoize.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/memoize.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/memoize.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,124 @@ +/** + * Creates a memoized version of the provided function. The memoized function caches + * results based on the argument it receives, so if the same argument is passed again, + * it returns the cached result instead of recomputing it. + * + * This function works with functions that take zero or just one argument. If your function + * originally takes multiple arguments, you should refactor it to take a single object or array + * that combines those arguments. + * + * If the argument is not primitive (e.g., arrays or objects), provide a + * `getCacheKey` function to generate a unique cache key for proper caching. + * + * @template F - The type of the function to be memoized. + * @param {F} fn - The function to be memoized. It should accept a single argument and return a value. + * @param {MemoizeOptions[0], ReturnType>} [options={}] - Optional configuration for the memoization. + * @param {MemoizeCache} [options.cache] - The cache object used to store results. Defaults to a new `Map`. + * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument. + * + * @returns The memoized function with an additional `cache` property that exposes the internal cache. + * + * @example + * // Example using the default cache + * const add = (x: number) => x + 10; + * const memoizedAdd = memoize(add); + * + * console.log(memoizedAdd(5)); // 15 + * console.log(memoizedAdd(5)); // 15 (cached result) + * console.log(memoizedAdd.cache.size); // 1 + * + * @example + * // Example using a custom resolver + * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0); + * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') }); + * console.log(memoizedSum([1, 2])); // 3 + * console.log(memoizedSum([1, 2])); // 3 (cached result) + * console.log(memoizedSum.cache.size); // 1 + * + * @example + * // Example using a custom cache implementation + * class CustomCache implements MemoizeCache { + * private cache = new Map(); + * + * set(key: K, value: T): void { + * this.cache.set(key, value); + * } + * + * get(key: K): T | undefined { + * return this.cache.get(key); + * } + * + * has(key: K): boolean { + * return this.cache.has(key); + * } + * + * delete(key: K): boolean { + * return this.cache.delete(key); + * } + * + * clear(): void { + * this.cache.clear(); + * } + * + * get size(): number { + * return this.cache.size; + * } + * } + * const customCache = new CustomCache(); + * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache }); + * console.log(memoizedSumWithCustomCache([1, 2])); // 3 + * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result) + * console.log(memoizedAddWithCustomCache.cache.size); // 1 + */ +declare function memoize any>(fn: F, options?: { + cache?: MemoizeCache>; + getCacheKey?: (args: Parameters[0]) => unknown; +}): F & { + cache: MemoizeCache>; +}; +/** + * Represents a cache for memoization, allowing storage and retrieval of computed values. + * + * @template K - The type of keys used to store values in the cache. + * @template V - The type of values stored in the cache. + */ +interface MemoizeCache { + /** + * Stores a value in the cache with the specified key. + * + * @param key - The key to associate with the value. + * @param value - The value to store in the cache. + */ + set(key: K, value: V): void; + /** + * Retrieves a value from the cache by its key. + * + * @param key - The key of the value to retrieve. + * @returns The value associated with the key, or undefined if the key does not exist. + */ + get(key: K): V | undefined; + /** + * Checks if a value exists in the cache for the specified key. + * + * @param key - The key to check for existence in the cache. + * @returns True if the cache contains the key, false otherwise. + */ + has(key: K): boolean; + /** + * Deletes a value from the cache by its key. + * + * @param key - The key of the value to delete. + * @returns True if the value was successfully deleted, false otherwise. + */ + delete(key: K): boolean | void; + /** + * Clears all values from the cache. + */ + clear(): void; + /** + * The number of entries in the cache. + */ + size: number; +} + +export { type MemoizeCache, memoize }; Index: node_modules/es-toolkit/dist/function/memoize.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/memoize.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/memoize.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,124 @@ +/** + * Creates a memoized version of the provided function. The memoized function caches + * results based on the argument it receives, so if the same argument is passed again, + * it returns the cached result instead of recomputing it. + * + * This function works with functions that take zero or just one argument. If your function + * originally takes multiple arguments, you should refactor it to take a single object or array + * that combines those arguments. + * + * If the argument is not primitive (e.g., arrays or objects), provide a + * `getCacheKey` function to generate a unique cache key for proper caching. + * + * @template F - The type of the function to be memoized. + * @param {F} fn - The function to be memoized. It should accept a single argument and return a value. + * @param {MemoizeOptions[0], ReturnType>} [options={}] - Optional configuration for the memoization. + * @param {MemoizeCache} [options.cache] - The cache object used to store results. Defaults to a new `Map`. + * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument. + * + * @returns The memoized function with an additional `cache` property that exposes the internal cache. + * + * @example + * // Example using the default cache + * const add = (x: number) => x + 10; + * const memoizedAdd = memoize(add); + * + * console.log(memoizedAdd(5)); // 15 + * console.log(memoizedAdd(5)); // 15 (cached result) + * console.log(memoizedAdd.cache.size); // 1 + * + * @example + * // Example using a custom resolver + * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0); + * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') }); + * console.log(memoizedSum([1, 2])); // 3 + * console.log(memoizedSum([1, 2])); // 3 (cached result) + * console.log(memoizedSum.cache.size); // 1 + * + * @example + * // Example using a custom cache implementation + * class CustomCache implements MemoizeCache { + * private cache = new Map(); + * + * set(key: K, value: T): void { + * this.cache.set(key, value); + * } + * + * get(key: K): T | undefined { + * return this.cache.get(key); + * } + * + * has(key: K): boolean { + * return this.cache.has(key); + * } + * + * delete(key: K): boolean { + * return this.cache.delete(key); + * } + * + * clear(): void { + * this.cache.clear(); + * } + * + * get size(): number { + * return this.cache.size; + * } + * } + * const customCache = new CustomCache(); + * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache }); + * console.log(memoizedSumWithCustomCache([1, 2])); // 3 + * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result) + * console.log(memoizedAddWithCustomCache.cache.size); // 1 + */ +declare function memoize any>(fn: F, options?: { + cache?: MemoizeCache>; + getCacheKey?: (args: Parameters[0]) => unknown; +}): F & { + cache: MemoizeCache>; +}; +/** + * Represents a cache for memoization, allowing storage and retrieval of computed values. + * + * @template K - The type of keys used to store values in the cache. + * @template V - The type of values stored in the cache. + */ +interface MemoizeCache { + /** + * Stores a value in the cache with the specified key. + * + * @param key - The key to associate with the value. + * @param value - The value to store in the cache. + */ + set(key: K, value: V): void; + /** + * Retrieves a value from the cache by its key. + * + * @param key - The key of the value to retrieve. + * @returns The value associated with the key, or undefined if the key does not exist. + */ + get(key: K): V | undefined; + /** + * Checks if a value exists in the cache for the specified key. + * + * @param key - The key to check for existence in the cache. + * @returns True if the cache contains the key, false otherwise. + */ + has(key: K): boolean; + /** + * Deletes a value from the cache by its key. + * + * @param key - The key of the value to delete. + * @returns True if the value was successfully deleted, false otherwise. + */ + delete(key: K): boolean | void; + /** + * Clears all values from the cache. + */ + clear(): void; + /** + * The number of entries in the cache. + */ + size: number; +} + +export { type MemoizeCache, memoize }; Index: node_modules/es-toolkit/dist/function/memoize.js =================================================================== --- node_modules/es-toolkit/dist/function/memoize.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/memoize.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function memoize(fn, options = {}) { + const { cache = new Map(), getCacheKey } = options; + const memoizedFn = function (arg) { + const key = getCacheKey ? getCacheKey(arg) : arg; + if (cache.has(key)) { + return cache.get(key); + } + const result = fn.call(this, arg); + cache.set(key, result); + return result; + }; + memoizedFn.cache = cache; + return memoizedFn; +} + +exports.memoize = memoize; Index: node_modules/es-toolkit/dist/function/memoize.mjs =================================================================== --- node_modules/es-toolkit/dist/function/memoize.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/memoize.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,16 @@ +function memoize(fn, options = {}) { + const { cache = new Map(), getCacheKey } = options; + const memoizedFn = function (arg) { + const key = getCacheKey ? getCacheKey(arg) : arg; + if (cache.has(key)) { + return cache.get(key); + } + const result = fn.call(this, arg); + cache.set(key, result); + return result; + }; + memoizedFn.cache = cache; + return memoizedFn; +} + +export { memoize }; Index: node_modules/es-toolkit/dist/function/negate.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/negate.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/negate.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,16 @@ +/** + * Creates a function that negates the result of the predicate function. + * + * @template F - The type of the function to negate. + * @param {F} func - The function to negate. + * @returns {F} The new negated function, which negates the boolean result of `func`. + * + * @example + * const array = [1, 2, 3, 4, 5, 6]; + * const isEven = (n: number) => n % 2 === 0; + * const result = array.filter(negate(isEven)); + * // result will be [1, 3, 5] + */ +declare function negate boolean>(func: F): F; + +export { negate }; Index: node_modules/es-toolkit/dist/function/negate.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/negate.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/negate.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,16 @@ +/** + * Creates a function that negates the result of the predicate function. + * + * @template F - The type of the function to negate. + * @param {F} func - The function to negate. + * @returns {F} The new negated function, which negates the boolean result of `func`. + * + * @example + * const array = [1, 2, 3, 4, 5, 6]; + * const isEven = (n: number) => n % 2 === 0; + * const result = array.filter(negate(isEven)); + * // result will be [1, 3, 5] + */ +declare function negate boolean>(func: F): F; + +export { negate }; Index: node_modules/es-toolkit/dist/function/negate.js =================================================================== --- node_modules/es-toolkit/dist/function/negate.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/negate.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function negate(func) { + return ((...args) => !func(...args)); +} + +exports.negate = negate; Index: node_modules/es-toolkit/dist/function/negate.mjs =================================================================== --- node_modules/es-toolkit/dist/function/negate.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/negate.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,5 @@ +function negate(func) { + return ((...args) => !func(...args)); +} + +export { negate }; Index: node_modules/es-toolkit/dist/function/noop.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/noop.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/noop.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +/** + * A no-operation function that does nothing. + * This can be used as a placeholder or default function. + * + * @example + * noop(); // Does nothing + * + * @returns {void} This function does not return anything. + */ +declare function noop(): void; + +export { noop }; Index: node_modules/es-toolkit/dist/function/noop.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/noop.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/noop.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +/** + * A no-operation function that does nothing. + * This can be used as a placeholder or default function. + * + * @example + * noop(); // Does nothing + * + * @returns {void} This function does not return anything. + */ +declare function noop(): void; + +export { noop }; Index: node_modules/es-toolkit/dist/function/noop.js =================================================================== --- node_modules/es-toolkit/dist/function/noop.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/noop.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function noop() { } + +exports.noop = noop; Index: node_modules/es-toolkit/dist/function/noop.mjs =================================================================== --- node_modules/es-toolkit/dist/function/noop.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/noop.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,3 @@ +function noop() { } + +export { noop }; Index: node_modules/es-toolkit/dist/function/once.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/once.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/once.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,17 @@ +/** + * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value of the first invocation. + * + * @template F - The type of the function. + * @param {F} func - The function to restrict. + * @returns {F} Returns the new restricted function. + * + * @example + * const initialize = once(createApplication); + * + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ +declare function once any>(func: F): F; + +export { once }; Index: node_modules/es-toolkit/dist/function/once.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/once.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/once.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,17 @@ +/** + * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value of the first invocation. + * + * @template F - The type of the function. + * @param {F} func - The function to restrict. + * @returns {F} Returns the new restricted function. + * + * @example + * const initialize = once(createApplication); + * + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ +declare function once any>(func: F): F; + +export { once }; Index: node_modules/es-toolkit/dist/function/once.js =================================================================== --- node_modules/es-toolkit/dist/function/once.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/once.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function once(func) { + let called = false; + let cache; + return function (...args) { + if (!called) { + called = true; + cache = func(...args); + } + return cache; + }; +} + +exports.once = once; Index: node_modules/es-toolkit/dist/function/once.mjs =================================================================== --- node_modules/es-toolkit/dist/function/once.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/once.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,13 @@ +function once(func) { + let called = false; + let cache; + return function (...args) { + if (!called) { + called = true; + cache = func(...args); + } + return cache; + }; +} + +export { once }; Index: node_modules/es-toolkit/dist/function/partial.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/partial.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/partial.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,551 @@ +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {function(arg1: T1): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(): R} A new function that takes no arguments and returns the result of the original function. + * + * @example + * const addOne = (x: number) => x + 1; + * const addOneToFive = partial(addOne, 5); + * console.log(addOneToFive()); // => 6 + */ +declare function partial(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number) => x * y; + * const double = partial(multiply, 2); + * console.log(double(5)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2) => R, arg1: T1): (arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2): R} func The function to partially apply. + * @param {Placeholder} placeholder The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithHello = partial(greet, partial.placeholder, 'John'); + * console.log(greetWithHello('Hello')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2) => R, placeholder: Placeholder, arg2: T2): (arg1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2, arg3: T3): R} A new function that takes the second and third arguments and returns the result of the original function. + * + * @example + * const sumThree = (a: number, b: number, c: number) => a + b + c; + * const addFive = partial(sumThree, 5); + * console.log(addFive(3, 2)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1): (arg2: T2, arg3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, partial.placeholder, 'John'); + * console.log(greetWithPlaceholder('Hello')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: Placeholder, arg2: T2): (arg1: T1, arg3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number) => x * y * z; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2); + * console.log(multiplyWithPlaceholders(3, 4)); // => 24 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3): (arg1: T1, arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The first argument to apply. + * @param {T2} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, plc1: Placeholder, arg2: T2, arg3: T3): (arg1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const double = partial(multiply, 2); + * console.log(double(5, 4, 3)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1): (arg2: T2, arg3: T3, arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholders(4, 5)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg3: T3, arg4: T4): R} A new function that takes the third and fourth arguments and returns the result of the original function. + * + * @example + * const sumFour = (a: number, b: number, c: number, d: number) => a + b + c + d; + * const addOneAndTwo = partial(sumFour, 1, 2); + * console.log(addOneAndTwo(3, 4)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2): (arg3: T3, arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg2: T2, arg4: T4): R} A new function that takes the second and fourth arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder, '!'); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2, arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholder = partial(multiply, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholder(4)); // => 24 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3): (arg1: T1, arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholders(4, 5)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg4: T4): R} A new function that takes the fourth argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3): (arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg3: T3): R} A new function that takes the third argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template R The return type of the function. + * @param {function(...args: TS): R} func The function to partially apply. + * @returns {function(...args: TS): R} A new function that takes the same arguments as the original function. + * + * @example + * const add = (...numbers: number[]) => numbers.reduce((sum, n) => sum + n, 0); + * const addFive = partial(add, 5); + * console.log(addFive(1, 2, 3)); // => 11 + */ +declare function partial(func: (...args: TS) => R): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {function(arg1: T1, ...args: TS): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, ...names: string[]) => `${greeting}, ${names.join(', ')}!`; + * const greetHello = partial(greet, 'Hello'); + * console.log(greetHello('Alice', 'Bob')); // => 'Hello, Alice, Bob!' + */ +declare function partial(func: (arg1: T1, ...args: TS) => R, arg1: T1): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, ...args: TS): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', '!'); + * console.log(greetWithHello('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, ...args: TS) => R, t1: T1, arg2: T2): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(t1: T1, arg2: T2, arg3: T3, ...args: TS): R} func The function to partially apply. + * @param {T1} t1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', 'John', '!'); + * console.log(greetWithHello()); // => 'Hello, John!' + */ +declare function partial(func: (t1: T1, arg2: T2, arg3: T3, ...args: TS) => R, t1: T1, arg2: T2, arg3: T3): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(t1: T1, arg2: T2, arg3: T3, arg4: T4, ...args: TS): R} func The function to partially apply. + * @param {T1} t1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', 'John', '!'); + * console.log(greetWithHello()); // => 'Hello, John!' + */ +declare function partial(func: (t1: T1, arg2: T2, arg3: T3, arg4: T4, ...args: TS) => R, t1: T1, arg2: T2, arg3: T3, arg4: T4): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template F The type of the function to partially apply. + * @param {F} func The function to partially apply. + * @param {...any[]} partialArgs The arguments to be partially applied. + * @returns {function(...args: any[]): ReturnType} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const add = (...numbers: number[]) => numbers.reduce((sum, n) => sum + n, 0); + * const addFive = partial(add, 5); + * console.log(addFive(1, 2, 3)); // => 11 + */ +declare function partial any>(func: F, ...partialArgs: any[]): (...args: any[]) => ReturnType; +declare namespace partial { + var placeholder: typeof placeholderSymbol; +} +declare const placeholderSymbol: unique symbol; +type Placeholder = typeof placeholderSymbol; + +export { partial }; Index: node_modules/es-toolkit/dist/function/partial.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/partial.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/partial.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,551 @@ +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {function(arg1: T1): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(): R} A new function that takes no arguments and returns the result of the original function. + * + * @example + * const addOne = (x: number) => x + 1; + * const addOneToFive = partial(addOne, 5); + * console.log(addOneToFive()); // => 6 + */ +declare function partial(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number) => x * y; + * const double = partial(multiply, 2); + * console.log(double(5)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2) => R, arg1: T1): (arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2): R} func The function to partially apply. + * @param {Placeholder} placeholder The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithHello = partial(greet, partial.placeholder, 'John'); + * console.log(greetWithHello('Hello')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2) => R, placeholder: Placeholder, arg2: T2): (arg1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2, arg3: T3): R} A new function that takes the second and third arguments and returns the result of the original function. + * + * @example + * const sumThree = (a: number, b: number, c: number) => a + b + c; + * const addFive = partial(sumThree, 5); + * console.log(addFive(3, 2)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1): (arg2: T2, arg3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, partial.placeholder, 'John'); + * console.log(greetWithPlaceholder('Hello')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: Placeholder, arg2: T2): (arg1: T1, arg3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number) => x * y * z; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2); + * console.log(multiplyWithPlaceholders(3, 4)); // => 24 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3): (arg1: T1, arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The first argument to apply. + * @param {T2} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, plc1: Placeholder, arg2: T2, arg3: T3): (arg1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const double = partial(multiply, 2); + * console.log(double(5, 4, 3)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1): (arg2: T2, arg3: T3, arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholders(4, 5)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg3: T3, arg4: T4): R} A new function that takes the third and fourth arguments and returns the result of the original function. + * + * @example + * const sumFour = (a: number, b: number, c: number, d: number) => a + b + c + d; + * const addOneAndTwo = partial(sumFour, 1, 2); + * console.log(addOneAndTwo(3, 4)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2): (arg3: T3, arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg2: T2, arg4: T4): R} A new function that takes the second and fourth arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder, '!'); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2, arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholder = partial(multiply, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholder(4)); // => 24 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3): (arg1: T1, arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholders(4, 5)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg4: T4): R} A new function that takes the fourth argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3): (arg4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg3: T3): R} A new function that takes the third argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template R The return type of the function. + * @param {function(...args: TS): R} func The function to partially apply. + * @returns {function(...args: TS): R} A new function that takes the same arguments as the original function. + * + * @example + * const add = (...numbers: number[]) => numbers.reduce((sum, n) => sum + n, 0); + * const addFive = partial(add, 5); + * console.log(addFive(1, 2, 3)); // => 11 + */ +declare function partial(func: (...args: TS) => R): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {function(arg1: T1, ...args: TS): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, ...names: string[]) => `${greeting}, ${names.join(', ')}!`; + * const greetHello = partial(greet, 'Hello'); + * console.log(greetHello('Alice', 'Bob')); // => 'Hello, Alice, Bob!' + */ +declare function partial(func: (arg1: T1, ...args: TS) => R, arg1: T1): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {function(arg1: T1, arg2: T2, ...args: TS): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', '!'); + * console.log(greetWithHello('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, ...args: TS) => R, t1: T1, arg2: T2): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {function(t1: T1, arg2: T2, arg3: T3, ...args: TS): R} func The function to partially apply. + * @param {T1} t1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', 'John', '!'); + * console.log(greetWithHello()); // => 'Hello, John!' + */ +declare function partial(func: (t1: T1, arg2: T2, arg3: T3, ...args: TS) => R, t1: T1, arg2: T2, arg3: T3): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {function(t1: T1, arg2: T2, arg3: T3, arg4: T4, ...args: TS): R} func The function to partially apply. + * @param {T1} t1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', 'John', '!'); + * console.log(greetWithHello()); // => 'Hello, John!' + */ +declare function partial(func: (t1: T1, arg2: T2, arg3: T3, arg4: T4, ...args: TS) => R, t1: T1, arg2: T2, arg3: T3, arg4: T4): (...args: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template F The type of the function to partially apply. + * @param {F} func The function to partially apply. + * @param {...any[]} partialArgs The arguments to be partially applied. + * @returns {function(...args: any[]): ReturnType} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const add = (...numbers: number[]) => numbers.reduce((sum, n) => sum + n, 0); + * const addFive = partial(add, 5); + * console.log(addFive(1, 2, 3)); // => 11 + */ +declare function partial any>(func: F, ...partialArgs: any[]): (...args: any[]) => ReturnType; +declare namespace partial { + var placeholder: typeof placeholderSymbol; +} +declare const placeholderSymbol: unique symbol; +type Placeholder = typeof placeholderSymbol; + +export { partial }; Index: node_modules/es-toolkit/dist/function/partial.js =================================================================== --- node_modules/es-toolkit/dist/function/partial.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/partial.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function partial(func, ...partialArgs) { + return partialImpl(func, placeholderSymbol, ...partialArgs); +} +function partialImpl(func, placeholder, ...partialArgs) { + const partialed = function (...providedArgs) { + let providedArgsIndex = 0; + const substitutedArgs = partialArgs + .slice() + .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg)); + const remainingArgs = providedArgs.slice(providedArgsIndex); + return func.apply(this, substitutedArgs.concat(remainingArgs)); + }; + if (func.prototype) { + partialed.prototype = Object.create(func.prototype); + } + return partialed; +} +const placeholderSymbol = Symbol('partial.placeholder'); +partial.placeholder = placeholderSymbol; + +exports.partial = partial; +exports.partialImpl = partialImpl; Index: node_modules/es-toolkit/dist/function/partial.mjs =================================================================== --- node_modules/es-toolkit/dist/function/partial.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/partial.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +function partial(func, ...partialArgs) { + return partialImpl(func, placeholderSymbol, ...partialArgs); +} +function partialImpl(func, placeholder, ...partialArgs) { + const partialed = function (...providedArgs) { + let providedArgsIndex = 0; + const substitutedArgs = partialArgs + .slice() + .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg)); + const remainingArgs = providedArgs.slice(providedArgsIndex); + return func.apply(this, substitutedArgs.concat(remainingArgs)); + }; + if (func.prototype) { + partialed.prototype = Object.create(func.prototype); + } + return partialed; +} +const placeholderSymbol = Symbol('partial.placeholder'); +partial.placeholder = placeholderSymbol; + +export { partial, partialImpl }; Index: node_modules/es-toolkit/dist/function/partialRight.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/partialRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/partialRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,628 @@ +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template R The return type of the function. + * @param {() => R} func The function to invoke. + * @returns {() => R} Returns the new function. + * @example + * const getValue = () => 42; + * const getValueFunc = partialRight(getValue); + * console.log(getValueFunc()); // => 42 + */ +declare function partialRight(func: () => R): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const addOne = (num: number) => num + 1; + * const addOneFunc = partialRight(addOne, 1); + * console.log(addOneFunc()); // => 2 + */ +declare function partialRight(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const multiplyBy = (factor: number) => (num: number) => num * factor; + * const double = partialRight(multiplyBy(2)); + * console.log(double(5)); // => 10 + */ +declare function partialRight(func: (arg1: T1) => R): (arg1: T1) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const greet = (name: string) => `Hello, ${name}!`; + * const greetJohn = partialRight(greet, 'John'); + * console.log(greetJohn()); // => 'Hello, John!' + */ +declare function partialRight(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2) => R} Returns the new partially applied function. + * @example + * const subtract = (a: number, b: number) => a - b; + * const subtractFive = partialRight(subtract); + * console.log(subtractFive(10, 5)); // => 5 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @returns {(arg2: T2) => R} Returns the new partially applied function. + * @example + * const concat = (a: string, b: string) => a + b; + * const concatWithHello = partialRight(concat, 'Hello', partialRight.placeholder); + * console.log(concatWithHello(' World!')); // => 'Hello World!' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const divide = (a: number, b: number) => a / b; + * const divideByTwo = partialRight(divide, 2); + * console.log(divideByTwo(10)); // => 5 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const multiply = (a: number, b: number) => a * b; + * const multiplyByThreeAndFour = partialRight(multiply, 3, 4); + * console.log(multiplyByThreeAndFour()); // => 12 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2, arg3: T3) => R} Returns the new partially applied function. + * @example + * const sumThree = (a: number, b: number, c: number) => a + b + c; + * const sumWithFive = partialRight(sumThree); + * console.log(sumWithFive(1, 2, 5)); // => 8 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg2: T2, arg3: T3) => R} Returns the new partially applied function. + * @example + * const formatDate = (day: number, month: number, year: number) => `${day}/${month}/${year}`; + * const formatDateWithDay = partialRight(formatDate, 1, partialRight.placeholder, partialRight.placeholder); + * console.log(formatDateWithDay(12, 2023)); // => '1/12/2023' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg1: T1, arg3: T3) => R} Returns the new partially applied function. + * @example + * const createUser = (name: string, age: number, country: string) => `${name}, ${age} years old from ${country}`; + * const createUserFromUSA = partialRight(createUser, 'USA', partialRight.placeholder); + * console.log(createUserFromUSA('John', 30)); // => 'John, 30 years old from USA' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg3: T3) => R} Returns the new partially applied function. + * @example + * const logMessage = (level: string, message: string, timestamp: string) => `[${level}] ${message} at ${timestamp}`; + * const logError = partialRight(logMessage, 'ERROR', '2023-10-01'); + * console.log(logError('Something went wrong!')); // => '[ERROR] Something went wrong! at 2023-10-01' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg1: T1, arg2: T2) => R} Returns the new partially applied function. + * @example + * const calculateArea = (length: number, width: number) => length * width; + * const calculateAreaWithWidth = partialRight(calculateArea, 5); + * console.log(calculateAreaWithWidth(10)); // => 50 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg2: T2) => R} Returns the new partially applied function. + * @example + * const formatCurrency = (amount: number, currency: string) => `${amount} ${currency}`; + * const formatUSD = partialRight(formatCurrency, 100, partialRight.placeholder); + * console.log(formatUSD('USD')); // => '100 USD' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const createProfile = (name: string, age: number, country: string) => `${name}, ${age} from ${country}`; + * const createProfileFromCanada = partialRight(createProfile, 'Canada', 'John'); + * console.log(createProfileFromCanada(30)); // => 'John, 30 from Canada' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: T3): (arg1: T1) => R; +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} Returns a new function that takes four arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg2: T2, arg3: T3, arg4: T4) => R} Returns a new function that takes the second, third, and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg3: T3, arg4: T4) => R} Returns a new function that takes the first, third, and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg3: T3, arg4: T4) => R} Returns a new function that takes the third and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg2: T2, arg4: T4) => R} Returns a new function that takes the first, second, and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg2: T2, arg4: T4) => R} Returns a new function that takes the second and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg4: T4) => R} Returns a new function that takes the first and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg4: T4) => R} Returns a new function that takes the fourth argument. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg2: T2, arg3: T3) => R} Returns a new function that takes the first, second, and third arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg2: T2, arg3: T3) => R} Returns a new function that takes the second and third arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg3: T3) => R} Returns a new function that takes the first and third arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg3: T3) => R} Returns a new function that takes the third argument. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg2: T2) => R} Returns a new function that takes the first and second arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg2: T2) => R} Returns a new function that takes the second argument. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1) => R} Returns a new function that takes the first argument. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const concatenate = (a: string, b: string, c: string, d: string) => a + b + c + d; + * const concatenateHelloWorld = partialRight(concatenate, 'Hello', ' ', 'World', '!'); + * console.log(concatenateHelloWorld()); // => 'Hello World!' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template F The type of the function to partially apply. + * @param {F} func The function to partially apply arguments to. + * @param {...any[]} args The arguments to be partially applied. + * @returns {function(...args: any[]): ReturnType} Returns the new partially applied function. + * @example + * const log = (...messages: string[]) => console.log(...messages); + * const logError = partialRight(log, 'Error:'); + * logError('Something went wrong!'); // => 'Error: Something went wrong!' + */ +declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; +declare namespace partialRight { + var placeholder: typeof placeholderSymbol; +} +declare const placeholderSymbol: unique symbol; +type Placeholder = typeof placeholderSymbol; + +export { partialRight }; Index: node_modules/es-toolkit/dist/function/partialRight.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/partialRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/partialRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,628 @@ +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template R The return type of the function. + * @param {() => R} func The function to invoke. + * @returns {() => R} Returns the new function. + * @example + * const getValue = () => 42; + * const getValueFunc = partialRight(getValue); + * console.log(getValueFunc()); // => 42 + */ +declare function partialRight(func: () => R): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const addOne = (num: number) => num + 1; + * const addOneFunc = partialRight(addOne, 1); + * console.log(addOneFunc()); // => 2 + */ +declare function partialRight(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const multiplyBy = (factor: number) => (num: number) => num * factor; + * const double = partialRight(multiplyBy(2)); + * console.log(double(5)); // => 10 + */ +declare function partialRight(func: (arg1: T1) => R): (arg1: T1) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const greet = (name: string) => `Hello, ${name}!`; + * const greetJohn = partialRight(greet, 'John'); + * console.log(greetJohn()); // => 'Hello, John!' + */ +declare function partialRight(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2) => R} Returns the new partially applied function. + * @example + * const subtract = (a: number, b: number) => a - b; + * const subtractFive = partialRight(subtract); + * console.log(subtractFive(10, 5)); // => 5 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @returns {(arg2: T2) => R} Returns the new partially applied function. + * @example + * const concat = (a: string, b: string) => a + b; + * const concatWithHello = partialRight(concat, 'Hello', partialRight.placeholder); + * console.log(concatWithHello(' World!')); // => 'Hello World!' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const divide = (a: number, b: number) => a / b; + * const divideByTwo = partialRight(divide, 2); + * console.log(divideByTwo(10)); // => 5 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const multiply = (a: number, b: number) => a * b; + * const multiplyByThreeAndFour = partialRight(multiply, 3, 4); + * console.log(multiplyByThreeAndFour()); // => 12 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2, arg3: T3) => R} Returns the new partially applied function. + * @example + * const sumThree = (a: number, b: number, c: number) => a + b + c; + * const sumWithFive = partialRight(sumThree); + * console.log(sumWithFive(1, 2, 5)); // => 8 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg2: T2, arg3: T3) => R} Returns the new partially applied function. + * @example + * const formatDate = (day: number, month: number, year: number) => `${day}/${month}/${year}`; + * const formatDateWithDay = partialRight(formatDate, 1, partialRight.placeholder, partialRight.placeholder); + * console.log(formatDateWithDay(12, 2023)); // => '1/12/2023' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg1: T1, arg3: T3) => R} Returns the new partially applied function. + * @example + * const createUser = (name: string, age: number, country: string) => `${name}, ${age} years old from ${country}`; + * const createUserFromUSA = partialRight(createUser, 'USA', partialRight.placeholder); + * console.log(createUserFromUSA('John', 30)); // => 'John, 30 years old from USA' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg3: T3) => R} Returns the new partially applied function. + * @example + * const logMessage = (level: string, message: string, timestamp: string) => `[${level}] ${message} at ${timestamp}`; + * const logError = partialRight(logMessage, 'ERROR', '2023-10-01'); + * console.log(logError('Something went wrong!')); // => '[ERROR] Something went wrong! at 2023-10-01' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg1: T1, arg2: T2) => R} Returns the new partially applied function. + * @example + * const calculateArea = (length: number, width: number) => length * width; + * const calculateAreaWithWidth = partialRight(calculateArea, 5); + * console.log(calculateAreaWithWidth(10)); // => 50 + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg2: T2) => R} Returns the new partially applied function. + * @example + * const formatCurrency = (amount: number, currency: string) => `${amount} ${currency}`; + * const formatUSD = partialRight(formatCurrency, 100, partialRight.placeholder); + * console.log(formatUSD('USD')); // => '100 USD' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const createProfile = (name: string, age: number, country: string) => `${name}, ${age} from ${country}`; + * const createProfileFromCanada = partialRight(createProfile, 'Canada', 'John'); + * console.log(createProfileFromCanada(30)); // => 'John, 30 from Canada' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: T3): (arg1: T1) => R; +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} Returns a new function that takes four arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg2: T2, arg3: T3, arg4: T4) => R} Returns a new function that takes the second, third, and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg3: T3, arg4: T4) => R} Returns a new function that takes the first, third, and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg3: T3, arg4: T4) => R} Returns a new function that takes the third and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg2: T2, arg4: T4) => R} Returns a new function that takes the first, second, and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg2: T2, arg4: T4) => R} Returns a new function that takes the second and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg4: T4) => R} Returns a new function that takes the first and fourth arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg4: T4) => R} Returns a new function that takes the fourth argument. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg2: T2, arg3: T3) => R} Returns a new function that takes the first, second, and third arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg2: T2, arg3: T3) => R} Returns a new function that takes the second and third arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg3: T3) => R} Returns a new function that takes the first and third arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg3: T3) => R} Returns a new function that takes the third argument. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg2: T2) => R} Returns a new function that takes the first and second arguments. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg2: T2) => R} Returns a new function that takes the second argument. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1) => R} Returns a new function that takes the first argument. + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template T2 The type of the second argument. + * @template T3 The type of the third argument. + * @template T4 The type of the fourth argument. + * @template R The return type of the function. + * @param {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const concatenate = (a: string, b: string, c: string, d: string) => a + b + c + d; + * const concatenateHelloWorld = partialRight(concatenate, 'Hello', ' ', 'World', '!'); + * console.log(concatenateHelloWorld()); // => 'Hello World!' + */ +declare function partialRight(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. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template F The type of the function to partially apply. + * @param {F} func The function to partially apply arguments to. + * @param {...any[]} args The arguments to be partially applied. + * @returns {function(...args: any[]): ReturnType} Returns the new partially applied function. + * @example + * const log = (...messages: string[]) => console.log(...messages); + * const logError = partialRight(log, 'Error:'); + * logError('Something went wrong!'); // => 'Error: Something went wrong!' + */ +declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; +declare namespace partialRight { + var placeholder: typeof placeholderSymbol; +} +declare const placeholderSymbol: unique symbol; +type Placeholder = typeof placeholderSymbol; + +export { partialRight }; Index: node_modules/es-toolkit/dist/function/partialRight.js =================================================================== --- node_modules/es-toolkit/dist/function/partialRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/partialRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,28 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function partialRight(func, ...partialArgs) { + return partialRightImpl(func, placeholderSymbol, ...partialArgs); +} +function partialRightImpl(func, placeholder, ...partialArgs) { + const partialedRight = function (...providedArgs) { + const placeholderLength = partialArgs.filter(arg => arg === placeholder).length; + const rangeLength = Math.max(providedArgs.length - placeholderLength, 0); + const remainingArgs = providedArgs.slice(0, rangeLength); + let providedArgsIndex = rangeLength; + const substitutedArgs = partialArgs + .slice() + .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg)); + return func.apply(this, remainingArgs.concat(substitutedArgs)); + }; + if (func.prototype) { + partialedRight.prototype = Object.create(func.prototype); + } + return partialedRight; +} +const placeholderSymbol = Symbol('partialRight.placeholder'); +partialRight.placeholder = placeholderSymbol; + +exports.partialRight = partialRight; +exports.partialRightImpl = partialRightImpl; Index: node_modules/es-toolkit/dist/function/partialRight.mjs =================================================================== --- node_modules/es-toolkit/dist/function/partialRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/partialRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,23 @@ +function partialRight(func, ...partialArgs) { + return partialRightImpl(func, placeholderSymbol, ...partialArgs); +} +function partialRightImpl(func, placeholder, ...partialArgs) { + const partialedRight = function (...providedArgs) { + const placeholderLength = partialArgs.filter(arg => arg === placeholder).length; + const rangeLength = Math.max(providedArgs.length - placeholderLength, 0); + const remainingArgs = providedArgs.slice(0, rangeLength); + let providedArgsIndex = rangeLength; + const substitutedArgs = partialArgs + .slice() + .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg)); + return func.apply(this, remainingArgs.concat(substitutedArgs)); + }; + if (func.prototype) { + partialedRight.prototype = Object.create(func.prototype); + } + return partialedRight; +} +const placeholderSymbol = Symbol('partialRight.placeholder'); +partialRight.placeholder = placeholderSymbol; + +export { partialRight, partialRightImpl }; Index: node_modules/es-toolkit/dist/function/rest.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/rest.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/rest.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,33 @@ +/** + * 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 + * are grouped into an array, while the previous arguments are passed as individual elements. + * + * @template F - The type of the function being transformed. + * @param {F} func - The function whose arguments are to be transformed. + * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array. + * Defaults to `func.length - 1`, grouping all arguments after the last parameter. + * @returns {(...args: any[]) => ReturnType} A new function that, when called, returns the result of calling `func` with the transformed arguments. + * + * The transformed arguments are: + * - The first `start` arguments as individual elements. + * - The remaining arguments from index `start` onward grouped into an array. + * @example + * function fn(a, b, c) { + * return [a, b, c]; + * } + * + * // Using default start index (func.length - 1, which is 2 in this case) + * const transformedFn = rest(fn); + * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]] + * + * // Using start index 1 + * const transformedFnWithStart = rest(fn, 1); + * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]] + * + * // With fewer arguments than the start index + * console.log(transformedFn(1)); // [1, undefined, []] + */ +declare function rest any>(func: F, startIndex?: number): (...args: any[]) => ReturnType; + +export { rest }; Index: node_modules/es-toolkit/dist/function/rest.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/rest.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/rest.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,33 @@ +/** + * 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 + * are grouped into an array, while the previous arguments are passed as individual elements. + * + * @template F - The type of the function being transformed. + * @param {F} func - The function whose arguments are to be transformed. + * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array. + * Defaults to `func.length - 1`, grouping all arguments after the last parameter. + * @returns {(...args: any[]) => ReturnType} A new function that, when called, returns the result of calling `func` with the transformed arguments. + * + * The transformed arguments are: + * - The first `start` arguments as individual elements. + * - The remaining arguments from index `start` onward grouped into an array. + * @example + * function fn(a, b, c) { + * return [a, b, c]; + * } + * + * // Using default start index (func.length - 1, which is 2 in this case) + * const transformedFn = rest(fn); + * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]] + * + * // Using start index 1 + * const transformedFnWithStart = rest(fn, 1); + * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]] + * + * // With fewer arguments than the start index + * console.log(transformedFn(1)); // [1, undefined, []] + */ +declare function rest any>(func: F, startIndex?: number): (...args: any[]) => ReturnType; + +export { rest }; Index: node_modules/es-toolkit/dist/function/rest.js =================================================================== --- node_modules/es-toolkit/dist/function/rest.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/rest.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function rest(func, startIndex = func.length - 1) { + return function (...args) { + const rest = args.slice(startIndex); + const params = args.slice(0, startIndex); + while (params.length < startIndex) { + params.push(undefined); + } + return func.apply(this, [...params, rest]); + }; +} + +exports.rest = rest; Index: node_modules/es-toolkit/dist/function/rest.mjs =================================================================== --- node_modules/es-toolkit/dist/function/rest.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/rest.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +function rest(func, startIndex = func.length - 1) { + return function (...args) { + const rest = args.slice(startIndex); + const params = args.slice(0, startIndex); + while (params.length < startIndex) { + params.push(undefined); + } + return func.apply(this, [...params, rest]); + }; +} + +export { rest }; Index: node_modules/es-toolkit/dist/function/retry.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/retry.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/retry.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,90 @@ +interface RetryOptions { + /** + * Delay between retries. Can be a static number (milliseconds) or a function + * that computes delay dynamically based on the current attempt. + * + * @default 0 + * @example + * delay: (attempts) => attempt * 50 + */ + delay?: number | ((attempts: number) => number); + /** + * The number of retries to attempt. + * @default Number.POSITIVE_INFINITY + */ + retries?: number; + /** + * An AbortSignal to cancel the retry operation. + */ + signal?: AbortSignal; + /** + * A function that determines whether to retry based on the error and attempt number. + * If not provided, all errors will trigger a retry. + * + * @param {unknown} error - The error that occurred. + * @param {number} attempt - The current attempt number (0-indexed). + * @returns {boolean} Whether to retry. + * + * @example + * shouldRetry: (error, attempt) => error.status >= 500 + */ + shouldRetry?: (error: unknown, attempt: number) => boolean; +} +/** + * Retries a function that returns a promise until it resolves successfully. + * + * @template T + * @param {() => Promise} func - The function to retry. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Basic usage with default retry options + * retry(() => fetchData()).then(data => console.log(data)); + */ +declare function retry(func: () => Promise): Promise; +/** + * Retries a function that returns a promise a specified number of times. + * + * @template T + * @param {() => Promise} func - The function to retry. It should return a promise. + * @param {number} retries - The number of retries to attempt. Default is Infinity. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Retry a function up to 3 times + * retry(() => fetchData(), 3).then(data => console.log(data)); + */ +declare function retry(func: () => Promise, retries: number): Promise; +/** + * Retries a function that returns a promise with specified options. + * + * @template T + * @param {() => Promise} func - The function to retry. It should return a promise. + * @param {RetryOptions} options - Options to configure the retry behavior. + * @param {number | ((attempts: number) => number)} [options.delay=0] - Delay(milliseconds) between retries. + * @param {number} [options.retries=Infinity] - The number of retries to attempt. + * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation. + * @param {(error: unknown, attempt: number) => boolean} [options.shouldRetry] - A function that determines whether to retry. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Retry a function with a delay of 1000ms between attempts + * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data)); + * + * @example + * // Retry a function with a fixed delay + * retry(() => fetchData(), { delay: 1000, retries: 5 }); + * + * // Retry a function with a delay increasing linearly by 50ms per attempt + * retry(() => fetchData(), { delay: (attempts) => attempt * 50, retries: 5 }); + * + * @example + * // Retry a function with exponential backoff + jitter (max delay 10 seconds) + * retry(() => fetchData(), { + * delay: (attempts) => Math.min(Math.random() * 100 * 2 ** attempts, 10000), + * retries: 5 + * }); + */ +declare function retry(func: () => Promise, options: RetryOptions): Promise; + +export { retry }; Index: node_modules/es-toolkit/dist/function/retry.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/retry.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/retry.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,90 @@ +interface RetryOptions { + /** + * Delay between retries. Can be a static number (milliseconds) or a function + * that computes delay dynamically based on the current attempt. + * + * @default 0 + * @example + * delay: (attempts) => attempt * 50 + */ + delay?: number | ((attempts: number) => number); + /** + * The number of retries to attempt. + * @default Number.POSITIVE_INFINITY + */ + retries?: number; + /** + * An AbortSignal to cancel the retry operation. + */ + signal?: AbortSignal; + /** + * A function that determines whether to retry based on the error and attempt number. + * If not provided, all errors will trigger a retry. + * + * @param {unknown} error - The error that occurred. + * @param {number} attempt - The current attempt number (0-indexed). + * @returns {boolean} Whether to retry. + * + * @example + * shouldRetry: (error, attempt) => error.status >= 500 + */ + shouldRetry?: (error: unknown, attempt: number) => boolean; +} +/** + * Retries a function that returns a promise until it resolves successfully. + * + * @template T + * @param {() => Promise} func - The function to retry. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Basic usage with default retry options + * retry(() => fetchData()).then(data => console.log(data)); + */ +declare function retry(func: () => Promise): Promise; +/** + * Retries a function that returns a promise a specified number of times. + * + * @template T + * @param {() => Promise} func - The function to retry. It should return a promise. + * @param {number} retries - The number of retries to attempt. Default is Infinity. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Retry a function up to 3 times + * retry(() => fetchData(), 3).then(data => console.log(data)); + */ +declare function retry(func: () => Promise, retries: number): Promise; +/** + * Retries a function that returns a promise with specified options. + * + * @template T + * @param {() => Promise} func - The function to retry. It should return a promise. + * @param {RetryOptions} options - Options to configure the retry behavior. + * @param {number | ((attempts: number) => number)} [options.delay=0] - Delay(milliseconds) between retries. + * @param {number} [options.retries=Infinity] - The number of retries to attempt. + * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation. + * @param {(error: unknown, attempt: number) => boolean} [options.shouldRetry] - A function that determines whether to retry. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Retry a function with a delay of 1000ms between attempts + * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data)); + * + * @example + * // Retry a function with a fixed delay + * retry(() => fetchData(), { delay: 1000, retries: 5 }); + * + * // Retry a function with a delay increasing linearly by 50ms per attempt + * retry(() => fetchData(), { delay: (attempts) => attempt * 50, retries: 5 }); + * + * @example + * // Retry a function with exponential backoff + jitter (max delay 10 seconds) + * retry(() => fetchData(), { + * delay: (attempts) => Math.min(Math.random() * 100 * 2 ** attempts, 10000), + * retries: 5 + * }); + */ +declare function retry(func: () => Promise, options: RetryOptions): Promise; + +export { retry }; Index: node_modules/es-toolkit/dist/function/retry.js =================================================================== --- node_modules/es-toolkit/dist/function/retry.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/retry.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,47 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const delay = require('../promise/delay.js'); + +const DEFAULT_DELAY = 0; +const DEFAULT_RETRIES = Number.POSITIVE_INFINITY; +const DEFAULT_SHOULD_RETRY = () => true; +async function retry(func, _options) { + let delay$1; + let retries; + let signal; + let shouldRetry; + if (typeof _options === 'number') { + delay$1 = DEFAULT_DELAY; + retries = _options; + signal = undefined; + shouldRetry = DEFAULT_SHOULD_RETRY; + } + else { + delay$1 = _options?.delay ?? DEFAULT_DELAY; + retries = _options?.retries ?? DEFAULT_RETRIES; + signal = _options?.signal; + shouldRetry = _options?.shouldRetry ?? DEFAULT_SHOULD_RETRY; + } + let error; + for (let attempts = 0; attempts < retries; attempts++) { + if (signal?.aborted) { + throw error ?? new Error(`The retry operation was aborted due to an abort signal.`); + } + try { + return await func(); + } + catch (err) { + error = err; + if (!shouldRetry(err, attempts)) { + throw err; + } + const currentDelay = typeof delay$1 === 'function' ? delay$1(attempts) : delay$1; + await delay.delay(currentDelay); + } + } + throw error; +} + +exports.retry = retry; Index: node_modules/es-toolkit/dist/function/retry.mjs =================================================================== --- node_modules/es-toolkit/dist/function/retry.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/retry.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,43 @@ +import { delay } from '../promise/delay.mjs'; + +const DEFAULT_DELAY = 0; +const DEFAULT_RETRIES = Number.POSITIVE_INFINITY; +const DEFAULT_SHOULD_RETRY = () => true; +async function retry(func, _options) { + let delay$1; + let retries; + let signal; + let shouldRetry; + if (typeof _options === 'number') { + delay$1 = DEFAULT_DELAY; + retries = _options; + signal = undefined; + shouldRetry = DEFAULT_SHOULD_RETRY; + } + else { + delay$1 = _options?.delay ?? DEFAULT_DELAY; + retries = _options?.retries ?? DEFAULT_RETRIES; + signal = _options?.signal; + shouldRetry = _options?.shouldRetry ?? DEFAULT_SHOULD_RETRY; + } + let error; + for (let attempts = 0; attempts < retries; attempts++) { + if (signal?.aborted) { + throw error ?? new Error(`The retry operation was aborted due to an abort signal.`); + } + try { + return await func(); + } + catch (err) { + error = err; + if (!shouldRetry(err, attempts)) { + throw err; + } + const currentDelay = typeof delay$1 === 'function' ? delay$1(attempts) : delay$1; + await delay(currentDelay); + } + } + throw error; +} + +export { retry }; Index: node_modules/es-toolkit/dist/function/spread.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/spread.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/spread.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,19 @@ +/** + * Creates a new function that spreads elements of an array argument into individual arguments + * for the original function. + * + * @template F - A function type with any number of parameters and any return type. + * @param {F} func - The function to be transformed. It can be any function with any number of arguments. + * @returns {(argsArr: Parameters) => ReturnType} - A new function that takes an array of arguments and returns the result of calling the original function with those arguments. + * + * @example + * function add(a, b) { + * return a + b; + * } + * + * const spreadAdd = spread(add); + * console.log(spreadAdd([1, 2])); // Output: 3 + */ +declare function spread any>(func: F): (argsArr: Parameters) => ReturnType; + +export { spread }; Index: node_modules/es-toolkit/dist/function/spread.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/spread.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/spread.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,19 @@ +/** + * Creates a new function that spreads elements of an array argument into individual arguments + * for the original function. + * + * @template F - A function type with any number of parameters and any return type. + * @param {F} func - The function to be transformed. It can be any function with any number of arguments. + * @returns {(argsArr: Parameters) => ReturnType} - A new function that takes an array of arguments and returns the result of calling the original function with those arguments. + * + * @example + * function add(a, b) { + * return a + b; + * } + * + * const spreadAdd = spread(add); + * console.log(spreadAdd([1, 2])); // Output: 3 + */ +declare function spread any>(func: F): (argsArr: Parameters) => ReturnType; + +export { spread }; Index: node_modules/es-toolkit/dist/function/spread.js =================================================================== --- node_modules/es-toolkit/dist/function/spread.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/spread.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function spread(func) { + return function (argsArr) { + return func.apply(this, argsArr); + }; +} + +exports.spread = spread; Index: node_modules/es-toolkit/dist/function/spread.mjs =================================================================== --- node_modules/es-toolkit/dist/function/spread.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/spread.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +function spread(func) { + return function (argsArr) { + return func.apply(this, argsArr); + }; +} + +export { spread }; Index: node_modules/es-toolkit/dist/function/throttle.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/throttle.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/throttle.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,48 @@ +interface ThrottleOptions { + /** + * An optional AbortSignal to cancel the throttled function. + */ + signal?: AbortSignal; + /** + * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both. + * If `edges` includes "leading", the function will be invoked at the start of the delay period. + * If `edges` includes "trailing", the function will be invoked at the end of the delay period. + * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period. + * @default ["leading", "trailing"] + */ + edges?: Array<'leading' | 'trailing'>; +} +interface ThrottledFunction void> { + (...args: Parameters): void; + cancel: () => void; + flush: () => void; +} +/** + * Creates a throttled function that only invokes the provided function at most once + * per every `throttleMs` milliseconds. Subsequent calls to the throttled function + * within the wait time will not trigger the execution of the original function. + * + * @template F - The type of function. + * @param {F} func - The function to throttle. + * @param {number} throttleMs - The number of milliseconds to throttle executions to. + * @returns {(...args: Parameters) => void} A new throttled function that accepts the same parameters as the original function. + * + * @example + * const throttledFunction = throttle(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' immediately + * throttledFunction(); + * + * // Will not log anything as it is within the throttle time + * throttledFunction(); + * + * // After 1 second + * setTimeout(() => { + * throttledFunction(); // Will log 'Function executed' + * }, 1000); + */ +declare function throttle void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction; + +export { type ThrottleOptions, type ThrottledFunction, throttle }; Index: node_modules/es-toolkit/dist/function/throttle.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/throttle.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/throttle.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,48 @@ +interface ThrottleOptions { + /** + * An optional AbortSignal to cancel the throttled function. + */ + signal?: AbortSignal; + /** + * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both. + * If `edges` includes "leading", the function will be invoked at the start of the delay period. + * If `edges` includes "trailing", the function will be invoked at the end of the delay period. + * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period. + * @default ["leading", "trailing"] + */ + edges?: Array<'leading' | 'trailing'>; +} +interface ThrottledFunction void> { + (...args: Parameters): void; + cancel: () => void; + flush: () => void; +} +/** + * Creates a throttled function that only invokes the provided function at most once + * per every `throttleMs` milliseconds. Subsequent calls to the throttled function + * within the wait time will not trigger the execution of the original function. + * + * @template F - The type of function. + * @param {F} func - The function to throttle. + * @param {number} throttleMs - The number of milliseconds to throttle executions to. + * @returns {(...args: Parameters) => void} A new throttled function that accepts the same parameters as the original function. + * + * @example + * const throttledFunction = throttle(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' immediately + * throttledFunction(); + * + * // Will not log anything as it is within the throttle time + * throttledFunction(); + * + * // After 1 second + * setTimeout(() => { + * throttledFunction(); // Will log 'Function executed' + * }, 1000); + */ +declare function throttle void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction; + +export { type ThrottleOptions, type ThrottledFunction, throttle }; Index: node_modules/es-toolkit/dist/function/throttle.js =================================================================== --- node_modules/es-toolkit/dist/function/throttle.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/throttle.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const debounce = require('./debounce.js'); + +function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) { + let pendingAt = null; + const debounced = debounce.debounce(function (...args) { + pendingAt = Date.now(); + func.apply(this, args); + }, throttleMs, { signal, edges }); + const throttled = function (...args) { + if (pendingAt == null) { + pendingAt = Date.now(); + } + if (Date.now() - pendingAt >= throttleMs) { + pendingAt = Date.now(); + func.apply(this, args); + debounced.cancel(); + debounced.schedule(); + return; + } + debounced.apply(this, args); + }; + throttled.cancel = debounced.cancel; + throttled.flush = debounced.flush; + return throttled; +} + +exports.throttle = throttle; Index: node_modules/es-toolkit/dist/function/throttle.mjs =================================================================== --- node_modules/es-toolkit/dist/function/throttle.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/throttle.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,27 @@ +import { debounce } from './debounce.mjs'; + +function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) { + let pendingAt = null; + const debounced = debounce(function (...args) { + pendingAt = Date.now(); + func.apply(this, args); + }, throttleMs, { signal, edges }); + const throttled = function (...args) { + if (pendingAt == null) { + pendingAt = Date.now(); + } + if (Date.now() - pendingAt >= throttleMs) { + pendingAt = Date.now(); + func.apply(this, args); + debounced.cancel(); + debounced.schedule(); + return; + } + debounced.apply(this, args); + }; + throttled.cancel = debounced.cancel; + throttled.flush = debounced.flush; + return throttled; +} + +export { throttle }; Index: node_modules/es-toolkit/dist/function/unary.d.mts =================================================================== --- node_modules/es-toolkit/dist/function/unary.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/unary.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,17 @@ +/** + * Creates a function that accepts up to one argument, ignoring any additional arguments. + * + * @template F - The type of the function. + * @param {F} func - The function to cap arguments for. + * @returns {(...args: any[]) => ReturnType} Returns the new capped function. + * + * @example + * function fn(a, b, c) { + * console.log(arguments); + * } + * + * unary(fn)(1, 2, 3); // [Arguments] { '0': 1 } + */ +declare function unary any>(func: F): (...args: any[]) => ReturnType; + +export { unary }; Index: node_modules/es-toolkit/dist/function/unary.d.ts =================================================================== --- node_modules/es-toolkit/dist/function/unary.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/unary.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,17 @@ +/** + * Creates a function that accepts up to one argument, ignoring any additional arguments. + * + * @template F - The type of the function. + * @param {F} func - The function to cap arguments for. + * @returns {(...args: any[]) => ReturnType} Returns the new capped function. + * + * @example + * function fn(a, b, c) { + * console.log(arguments); + * } + * + * unary(fn)(1, 2, 3); // [Arguments] { '0': 1 } + */ +declare function unary any>(func: F): (...args: any[]) => ReturnType; + +export { unary }; Index: node_modules/es-toolkit/dist/function/unary.js =================================================================== --- node_modules/es-toolkit/dist/function/unary.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/unary.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const ary = require('./ary.js'); + +function unary(func) { + return ary.ary(func, 1); +} + +exports.unary = unary; Index: node_modules/es-toolkit/dist/function/unary.mjs =================================================================== --- node_modules/es-toolkit/dist/function/unary.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/function/unary.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +import { ary } from './ary.mjs'; + +function unary(func) { + return ary(func, 1); +} + +export { unary };