Index: node_modules/es-toolkit/dist/compat/function/after.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/after.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/after.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,24 @@ +/** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @template TFunc - The type of the function to be invoked. + * @param {number} n - The number of calls before `func` is invoked. + * @param {TFunc} func - The function to restrict. + * @returns {TFunc} Returns the new restricted function. + * @throws {TypeError} - If `func` is not a function. + * + * @example + * const saves = ['profile', 'settings']; + * const done = after(saves.length, () => { + * console.log('done saving!'); + * }); + * + * saves.forEach(type => { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */ +declare function after any>(n: number, func: TFunc): TFunc; + +export { after }; Index: node_modules/es-toolkit/dist/compat/function/after.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/after.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/after.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,24 @@ +/** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @template TFunc - The type of the function to be invoked. + * @param {number} n - The number of calls before `func` is invoked. + * @param {TFunc} func - The function to restrict. + * @returns {TFunc} Returns the new restricted function. + * @throws {TypeError} - If `func` is not a function. + * + * @example + * const saves = ['profile', 'settings']; + * const done = after(saves.length, () => { + * console.log('done saving!'); + * }); + * + * saves.forEach(type => { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */ +declare function after any>(n: number, func: TFunc): TFunc; + +export { after }; Index: node_modules/es-toolkit/dist/compat/function/after.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/after.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/after.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('../util/toInteger.js'); + +function after(n, func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + n = toInteger.toInteger(n); + return function (...args) { + if (--n < 1) { + return func.apply(this, args); + } + }; +} + +exports.after = after; Index: node_modules/es-toolkit/dist/compat/function/after.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/after.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/after.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,15 @@ +import { toInteger } from '../util/toInteger.mjs'; + +function after(n, func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + n = toInteger(n); + return function (...args) { + if (--n < 1) { + return func.apply(this, args); + } + }; +} + +export { after }; Index: node_modules/es-toolkit/dist/compat/function/ary.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/ary.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/ary.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,24 @@ +/** + * Creates a function that invokes func, with up to `n` arguments, ignoring any additional arguments. + * If `n` is not provided, it defaults to the function's length. + * + * @param {Function} func - The function to cap arguments for. + * @param {number} [n] - The arity cap. Defaults to func.length. + * @returns {Function} Returns the new capped function. + * + * @example + * function fn(a: number, b: number, c: number) { + * return Array.from(arguments); + * } + * + * // Cap at 2 arguments + * const capped = ary(fn, 2); + * capped(1, 2, 3); // [1, 2] + * + * // Default to function length + * const defaultCap = ary(fn); + * defaultCap(1, 2, 3); // [1, 2, 3] + */ +declare function ary(func: (...args: any[]) => any, n?: number): (...args: any[]) => any; + +export { ary }; Index: node_modules/es-toolkit/dist/compat/function/ary.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/ary.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/ary.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,24 @@ +/** + * Creates a function that invokes func, with up to `n` arguments, ignoring any additional arguments. + * If `n` is not provided, it defaults to the function's length. + * + * @param {Function} func - The function to cap arguments for. + * @param {number} [n] - The arity cap. Defaults to func.length. + * @returns {Function} Returns the new capped function. + * + * @example + * function fn(a: number, b: number, c: number) { + * return Array.from(arguments); + * } + * + * // Cap at 2 arguments + * const capped = ary(fn, 2); + * capped(1, 2, 3); // [1, 2] + * + * // Default to function length + * const defaultCap = ary(fn); + * defaultCap(1, 2, 3); // [1, 2, 3] + */ +declare function ary(func: (...args: any[]) => any, n?: number): (...args: any[]) => any; + +export { ary }; Index: node_modules/es-toolkit/dist/compat/function/ary.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/ary.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/ary.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const ary$1 = require('../../function/ary.js'); + +function ary(func, n = func.length, guard) { + if (guard) { + n = func.length; + } + if (Number.isNaN(n) || n < 0) { + n = 0; + } + return ary$1.ary(func, n); +} + +exports.ary = ary; Index: node_modules/es-toolkit/dist/compat/function/ary.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/ary.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/ary.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,13 @@ +import { ary as ary$1 } from '../../function/ary.mjs'; + +function ary(func, n = func.length, guard) { + if (guard) { + n = func.length; + } + if (Number.isNaN(n) || n < 0) { + n = 0; + } + return ary$1(func, n); +} + +export { ary }; Index: node_modules/es-toolkit/dist/compat/function/attempt.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/attempt.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/attempt.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,33 @@ +/** + * Attempts to execute a function with the provided arguments. + * If the function throws an error, it catches the error and returns it. + * If the caught error is not an instance of Error, it wraps it in a new Error. + * + * @param {(...args: any[]) => R} func - The function to be executed. + * @param {...any[]} args - The arguments to pass to the function. + * @returns {R | Error} The return value of the function if successful, or an Error if an exception is thrown. + * + * @template R - The type of the function return value. + * + * @example + * // Example 1: Successful execution + * const result = attempt((x, y) => x + y, 2, 3); + * console.log(result); // Output: 5 + * + * @example + * // Example 2: Function throws an error + * const errorResult = attempt(() => { + * throw new Error("Something went wrong"); + * }); + * console.log(errorResult); // Output: Error: Something went wrong + * + * @example + * // Example 3: Non-Error thrown + * const nonErrorResult = attempt(() => { + * throw "This is a string error"; + * }); + * console.log(nonErrorResult); // Output: Error: This is a string error + */ +declare function attempt(func: (...args: any[]) => R, ...args: any[]): R | Error; + +export { attempt }; Index: node_modules/es-toolkit/dist/compat/function/attempt.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/attempt.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/attempt.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,33 @@ +/** + * Attempts to execute a function with the provided arguments. + * If the function throws an error, it catches the error and returns it. + * If the caught error is not an instance of Error, it wraps it in a new Error. + * + * @param {(...args: any[]) => R} func - The function to be executed. + * @param {...any[]} args - The arguments to pass to the function. + * @returns {R | Error} The return value of the function if successful, or an Error if an exception is thrown. + * + * @template R - The type of the function return value. + * + * @example + * // Example 1: Successful execution + * const result = attempt((x, y) => x + y, 2, 3); + * console.log(result); // Output: 5 + * + * @example + * // Example 2: Function throws an error + * const errorResult = attempt(() => { + * throw new Error("Something went wrong"); + * }); + * console.log(errorResult); // Output: Error: Something went wrong + * + * @example + * // Example 3: Non-Error thrown + * const nonErrorResult = attempt(() => { + * throw "This is a string error"; + * }); + * console.log(nonErrorResult); // Output: Error: This is a string error + */ +declare function attempt(func: (...args: any[]) => R, ...args: any[]): R | Error; + +export { attempt }; Index: node_modules/es-toolkit/dist/compat/function/attempt.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/attempt.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/attempt.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function attempt(func, ...args) { + try { + return func(...args); + } + catch (e) { + return e instanceof Error ? e : new Error(e); + } +} + +exports.attempt = attempt; Index: node_modules/es-toolkit/dist/compat/function/attempt.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/attempt.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/attempt.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,10 @@ +function attempt(func, ...args) { + try { + return func(...args); + } + catch (e) { + return e instanceof Error ? e : new Error(e); + } +} + +export { attempt }; Index: node_modules/es-toolkit/dist/compat/function/before.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/before.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/before.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,26 @@ +/** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @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 } - A new function that: + * - Tracks the number of calls. + * - Invokes `func` until the `n-1`-th call. + * - Returns last result of `func`, if `n` is reached. + * @throws {TypeError} - If `func` is not a function. + * @example + * let count = 0; + * const before3 = before(3, () => ++count); + * + * before3(); // => 1 + * before3(); // => 2 + * before3(); // => 2 + */ +declare function before any>(n: number, func: F): F; + +export { before }; Index: node_modules/es-toolkit/dist/compat/function/before.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/before.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/before.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,26 @@ +/** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @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 } - A new function that: + * - Tracks the number of calls. + * - Invokes `func` until the `n-1`-th call. + * - Returns last result of `func`, if `n` is reached. + * @throws {TypeError} - If `func` is not a function. + * @example + * let count = 0; + * const before3 = before(3, () => ++count); + * + * before3(); // => 1 + * before3(); // => 2 + * before3(); // => 2 + */ +declare function before any>(n: number, func: F): F; + +export { before }; Index: node_modules/es-toolkit/dist/compat/function/before.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/before.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/before.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('../util/toInteger.js'); + +function before(n, func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + let result; + n = toInteger.toInteger(n); + return function (...args) { + if (--n > 0) { + result = func.apply(this, args); + } + if (n <= 1 && func) { + func = undefined; + } + return result; + }; +} + +exports.before = before; Index: node_modules/es-toolkit/dist/compat/function/before.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/before.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/before.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,20 @@ +import { toInteger } from '../util/toInteger.mjs'; + +function before(n, func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + let result; + n = toInteger(n); + return function (...args) { + if (--n > 0) { + result = func.apply(this, args); + } + if (n <= 1 && func) { + func = undefined; + } + return result; + }; +} + +export { before }; Index: node_modules/es-toolkit/dist/compat/function/bind.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/bind.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/bind.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,32 @@ +/** + * Creates a function that invokes `func` with the `this` binding of `thisArg` and `partials` prepended to the arguments it receives. + * + * The `bind.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: Unlike native `Function#bind`, this method doesn't set the `length` property of bound functions. + * + * @param {(...args: any[]) => any} func - The function to bind. + * @param {any} thisObj - The `this` binding of `func`. + * @param {...any} partialArgs - The arguments to be partially applied. + * @returns {(...args: any[]) => any} - Returns the new bound function. + * + * @example + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * const object = { user: 'fred' }; + * let bound = bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * bound = bind(greet, object, bind.placeholder, '!'); + * bound('hi'); + * // => 'hi fred!' + */ +declare function bind(func: (...args: any[]) => any, thisObj: any, ...partialArgs: any[]): (...args: any[]) => any; +declare namespace bind { + var placeholder: typeof bindPlaceholder; +} +declare const bindPlaceholder: unique symbol; + +export { bind }; Index: node_modules/es-toolkit/dist/compat/function/bind.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/bind.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/bind.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,32 @@ +/** + * Creates a function that invokes `func` with the `this` binding of `thisArg` and `partials` prepended to the arguments it receives. + * + * The `bind.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: Unlike native `Function#bind`, this method doesn't set the `length` property of bound functions. + * + * @param {(...args: any[]) => any} func - The function to bind. + * @param {any} thisObj - The `this` binding of `func`. + * @param {...any} partialArgs - The arguments to be partially applied. + * @returns {(...args: any[]) => any} - Returns the new bound function. + * + * @example + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * const object = { user: 'fred' }; + * let bound = bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * bound = bind(greet, object, bind.placeholder, '!'); + * bound('hi'); + * // => 'hi fred!' + */ +declare function bind(func: (...args: any[]) => any, thisObj: any, ...partialArgs: any[]): (...args: any[]) => any; +declare namespace bind { + var placeholder: typeof bindPlaceholder; +} +declare const bindPlaceholder: unique symbol; + +export { bind }; Index: node_modules/es-toolkit/dist/compat/function/bind.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/bind.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/bind.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function bind(func, thisObj, ...partialArgs) { + const bound = function (...providedArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === bind.placeholder) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + if (this instanceof bound) { + return new func(...args); + } + return func.apply(thisObj, args); + }; + return bound; +} +const bindPlaceholder = Symbol('bind.placeholder'); +bind.placeholder = bindPlaceholder; + +exports.bind = bind; Index: node_modules/es-toolkit/dist/compat/function/bind.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/bind.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/bind.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,27 @@ +function bind(func, thisObj, ...partialArgs) { + const bound = function (...providedArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === bind.placeholder) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + if (this instanceof bound) { + return new func(...args); + } + return func.apply(thisObj, args); + }; + return bound; +} +const bindPlaceholder = Symbol('bind.placeholder'); +bind.placeholder = bindPlaceholder; + +export { bind }; Index: node_modules/es-toolkit/dist/compat/function/bindKey.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/bindKey.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/bindKey.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,45 @@ +/** + * Creates a function that invokes the method at `object[key]` with `partialArgs` prepended to the arguments it receives. + * + * This method differs from `bind` by allowing bound functions to reference methods that may be redefined or don't yet exist. + * + * The `bindKey.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * @template T - The type of the object to bind. + * @template K - The type of the key to bind. + * @param {T} object - The object to invoke the method on. + * @param {K} key - The key of the method. + * @param {...any} partialArgs - The arguments to be partially applied. + * @returns {T[K] extends (...args: any[]) => any ? (...args: any[]) => ReturnType : never} - Returns the new bound function. + * + * @example + * const object = { + * user: 'fred', + * greet: function (greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * }, + * }; + * + * let bound = bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function (greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * bound = bindKey(object, 'greet', bindKey.placeholder, '!'); + * bound('hi'); + * // => 'hiya fred!' + */ +declare function bindKey(object: object, key: string, ...partialArgs: any[]): (...args: any[]) => any; +declare namespace bindKey { + var placeholder: typeof bindKeyPlaceholder; +} +declare const bindKeyPlaceholder: unique symbol; + +export { bindKey }; Index: node_modules/es-toolkit/dist/compat/function/bindKey.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/bindKey.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/bindKey.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,45 @@ +/** + * Creates a function that invokes the method at `object[key]` with `partialArgs` prepended to the arguments it receives. + * + * This method differs from `bind` by allowing bound functions to reference methods that may be redefined or don't yet exist. + * + * The `bindKey.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * @template T - The type of the object to bind. + * @template K - The type of the key to bind. + * @param {T} object - The object to invoke the method on. + * @param {K} key - The key of the method. + * @param {...any} partialArgs - The arguments to be partially applied. + * @returns {T[K] extends (...args: any[]) => any ? (...args: any[]) => ReturnType : never} - Returns the new bound function. + * + * @example + * const object = { + * user: 'fred', + * greet: function (greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * }, + * }; + * + * let bound = bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function (greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * bound = bindKey(object, 'greet', bindKey.placeholder, '!'); + * bound('hi'); + * // => 'hiya fred!' + */ +declare function bindKey(object: object, key: string, ...partialArgs: any[]): (...args: any[]) => any; +declare namespace bindKey { + var placeholder: typeof bindKeyPlaceholder; +} +declare const bindKeyPlaceholder: unique symbol; + +export { bindKey }; Index: node_modules/es-toolkit/dist/compat/function/bindKey.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/bindKey.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/bindKey.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function bindKey(object, key, ...partialArgs) { + const bound = function (...providedArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === bindKey.placeholder) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + if (this instanceof bound) { + return new object[key](...args); + } + return object[key].apply(object, args); + }; + return bound; +} +const bindKeyPlaceholder = Symbol('bindKey.placeholder'); +bindKey.placeholder = bindKeyPlaceholder; + +exports.bindKey = bindKey; Index: node_modules/es-toolkit/dist/compat/function/bindKey.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/bindKey.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/bindKey.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,27 @@ +function bindKey(object, key, ...partialArgs) { + const bound = function (...providedArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === bindKey.placeholder) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + if (this instanceof bound) { + return new object[key](...args); + } + return object[key].apply(object, args); + }; + return bound; +} +const bindKeyPlaceholder = Symbol('bindKey.placeholder'); +bindKey.placeholder = bindKeyPlaceholder; + +export { bindKey }; Index: node_modules/es-toolkit/dist/compat/function/curry.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/curry.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/curry.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,154 @@ +type __ = typeof curryPlaceholder; +interface CurriedFunction1 { + (): CurriedFunction1; + (t1: T1): R; +} +interface CurriedFunction2 { + (): CurriedFunction2; + (t1: T1): CurriedFunction1; + (t1: __, t2: T2): CurriedFunction1; + (t1: T1, t2: T2): R; +} +interface CurriedFunction3 { + (): CurriedFunction3; + (t1: T1): CurriedFunction2; + (t1: __, t2: T2): CurriedFunction2; + (t1: T1, t2: T2): CurriedFunction1; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: T1, t2: __, t3: T3): CurriedFunction1; + (t1: __, t2: T2, t3: T3): CurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; +} +interface CurriedFunction4 { + (): CurriedFunction4; + (t1: T1): CurriedFunction3; + (t1: __, t2: T2): CurriedFunction3; + (t1: T1, t2: T2): CurriedFunction2; + (t1: __, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: __, t2: T2, t3: T3): CurriedFunction2; + (t1: T1, t2: T2, t3: T3): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; +} +interface CurriedFunction5 { + (): CurriedFunction5; + (t1: T1): CurriedFunction4; + (t1: __, t2: T2): CurriedFunction4; + (t1: T1, t2: T2): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction4; + (t1: T1, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: T2, t3: T3): CurriedFunction3; + (t1: T1, t2: T2, t3: T3): CurriedFunction2; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: __, t5: T5): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; +} +/** + * Creates a curried function that accepts a single argument. + * @param {(t1: T1) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction1} - Returns the new curried function. + * @example + * const greet = (name: string) => `Hello ${name}`; + * const curriedGreet = curry(greet); + * curriedGreet('John'); // => 'Hello John' + */ +declare function curry(func: (t1: T1) => R, arity?: number): CurriedFunction1; +/** + * Creates a curried function that accepts two arguments. + * @param {(t1: T1, t2: T2) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction2} - Returns the new curried function. + * @example + * const add = (a: number, b: number) => a + b; + * const curriedAdd = curry(add); + * curriedAdd(1)(2); // => 3 + * curriedAdd(1, 2); // => 3 + */ +declare function curry(func: (t1: T1, t2: T2) => R, arity?: number): CurriedFunction2; +/** + * Creates a curried function that accepts three arguments. + * @param {(t1: T1, t2: T2, t3: T3) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction3} - Returns the new curried function. + * @example + * const volume = (l: number, w: number, h: number) => l * w * h; + * const curriedVolume = curry(volume); + * curriedVolume(2)(3)(4); // => 24 + * curriedVolume(2, 3)(4); // => 24 + * curriedVolume(2, 3, 4); // => 24 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): CurriedFunction3; +/** + * Creates a curried function that accepts four arguments. + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction4} - Returns the new curried function. + * @example + * const fn = (a: number, b: number, c: number, d: number) => a + b + c + d; + * const curriedFn = curry(fn); + * curriedFn(1)(2)(3)(4); // => 10 + * curriedFn(1, 2)(3, 4); // => 10 + * curriedFn(1, 2, 3, 4); // => 10 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): CurriedFunction4; +/** + * Creates a curried function that accepts five arguments. + * @param {(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction5} - Returns the new curried function. + * @example + * const fn = (a: number, b: number, c: number, d: number, e: number) => a + b + c + d + e; + * const curriedFn = curry(fn); + * curriedFn(1)(2)(3)(4)(5); // => 15 + * curriedFn(1, 2)(3, 4)(5); // => 15 + * curriedFn(1, 2, 3, 4, 5); // => 15 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): CurriedFunction5; +/** + * Creates a curried function that accepts any number of arguments. + * @param {(...args: any[]) => any} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {(...args: any[]) => any} - Returns the new curried function. + * @example + * const sum = (...args: number[]) => args.reduce((a, b) => a + b, 0); + * const curriedSum = curry(sum); + * curriedSum(1, 2, 3); // => 6 + * curriedSum(1)(2, 3); // => 6 + * curriedSum(1)(2)(3); // => 6 + */ +declare function curry(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; +declare namespace curry { + var placeholder: typeof curryPlaceholder; +} +declare const curryPlaceholder: unique symbol; + +export { curry }; Index: node_modules/es-toolkit/dist/compat/function/curry.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/curry.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/curry.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,154 @@ +type __ = typeof curryPlaceholder; +interface CurriedFunction1 { + (): CurriedFunction1; + (t1: T1): R; +} +interface CurriedFunction2 { + (): CurriedFunction2; + (t1: T1): CurriedFunction1; + (t1: __, t2: T2): CurriedFunction1; + (t1: T1, t2: T2): R; +} +interface CurriedFunction3 { + (): CurriedFunction3; + (t1: T1): CurriedFunction2; + (t1: __, t2: T2): CurriedFunction2; + (t1: T1, t2: T2): CurriedFunction1; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: T1, t2: __, t3: T3): CurriedFunction1; + (t1: __, t2: T2, t3: T3): CurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; +} +interface CurriedFunction4 { + (): CurriedFunction4; + (t1: T1): CurriedFunction3; + (t1: __, t2: T2): CurriedFunction3; + (t1: T1, t2: T2): CurriedFunction2; + (t1: __, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: __, t2: T2, t3: T3): CurriedFunction2; + (t1: T1, t2: T2, t3: T3): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; +} +interface CurriedFunction5 { + (): CurriedFunction5; + (t1: T1): CurriedFunction4; + (t1: __, t2: T2): CurriedFunction4; + (t1: T1, t2: T2): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction4; + (t1: T1, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: T2, t3: T3): CurriedFunction3; + (t1: T1, t2: T2, t3: T3): CurriedFunction2; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: __, t5: T5): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; +} +/** + * Creates a curried function that accepts a single argument. + * @param {(t1: T1) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction1} - Returns the new curried function. + * @example + * const greet = (name: string) => `Hello ${name}`; + * const curriedGreet = curry(greet); + * curriedGreet('John'); // => 'Hello John' + */ +declare function curry(func: (t1: T1) => R, arity?: number): CurriedFunction1; +/** + * Creates a curried function that accepts two arguments. + * @param {(t1: T1, t2: T2) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction2} - Returns the new curried function. + * @example + * const add = (a: number, b: number) => a + b; + * const curriedAdd = curry(add); + * curriedAdd(1)(2); // => 3 + * curriedAdd(1, 2); // => 3 + */ +declare function curry(func: (t1: T1, t2: T2) => R, arity?: number): CurriedFunction2; +/** + * Creates a curried function that accepts three arguments. + * @param {(t1: T1, t2: T2, t3: T3) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction3} - Returns the new curried function. + * @example + * const volume = (l: number, w: number, h: number) => l * w * h; + * const curriedVolume = curry(volume); + * curriedVolume(2)(3)(4); // => 24 + * curriedVolume(2, 3)(4); // => 24 + * curriedVolume(2, 3, 4); // => 24 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): CurriedFunction3; +/** + * Creates a curried function that accepts four arguments. + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction4} - Returns the new curried function. + * @example + * const fn = (a: number, b: number, c: number, d: number) => a + b + c + d; + * const curriedFn = curry(fn); + * curriedFn(1)(2)(3)(4); // => 10 + * curriedFn(1, 2)(3, 4); // => 10 + * curriedFn(1, 2, 3, 4); // => 10 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): CurriedFunction4; +/** + * Creates a curried function that accepts five arguments. + * @param {(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction5} - Returns the new curried function. + * @example + * const fn = (a: number, b: number, c: number, d: number, e: number) => a + b + c + d + e; + * const curriedFn = curry(fn); + * curriedFn(1)(2)(3)(4)(5); // => 15 + * curriedFn(1, 2)(3, 4)(5); // => 15 + * curriedFn(1, 2, 3, 4, 5); // => 15 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): CurriedFunction5; +/** + * Creates a curried function that accepts any number of arguments. + * @param {(...args: any[]) => any} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {(...args: any[]) => any} - Returns the new curried function. + * @example + * const sum = (...args: number[]) => args.reduce((a, b) => a + b, 0); + * const curriedSum = curry(sum); + * curriedSum(1, 2, 3); // => 6 + * curriedSum(1)(2, 3); // => 6 + * curriedSum(1)(2)(3); // => 6 + */ +declare function curry(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; +declare namespace curry { + var placeholder: typeof curryPlaceholder; +} +declare const curryPlaceholder: unique symbol; + +export { curry }; Index: node_modules/es-toolkit/dist/compat/function/curry.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/curry.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/curry.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,61 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function curry(func, arity = func.length, guard) { + arity = guard ? func.length : arity; + arity = Number.parseInt(arity, 10); + if (Number.isNaN(arity) || arity < 1) { + arity = 0; + } + const wrapper = function (...partialArgs) { + const holders = partialArgs.filter(item => item === curry.placeholder); + const length = partialArgs.length - holders.length; + if (length < arity) { + return makeCurry(func, arity - length, partialArgs); + } + if (this instanceof wrapper) { + return new func(...partialArgs); + } + return func.apply(this, partialArgs); + }; + wrapper.placeholder = curryPlaceholder; + return wrapper; +} +function makeCurry(func, arity, partialArgs) { + function wrapper(...providedArgs) { + const holders = providedArgs.filter(item => item === curry.placeholder); + const length = providedArgs.length - holders.length; + providedArgs = composeArgs(providedArgs, partialArgs); + if (length < arity) { + return makeCurry(func, arity - length, providedArgs); + } + if (this instanceof wrapper) { + return new func(...providedArgs); + } + return func.apply(this, providedArgs); + } + wrapper.placeholder = curryPlaceholder; + return wrapper; +} +function composeArgs(providedArgs, partialArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === curry.placeholder && startIndex < providedArgs.length) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + return args; +} +const curryPlaceholder = Symbol('curry.placeholder'); +curry.placeholder = curryPlaceholder; + +exports.curry = curry; Index: node_modules/es-toolkit/dist/compat/function/curry.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/curry.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/curry.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,57 @@ +function curry(func, arity = func.length, guard) { + arity = guard ? func.length : arity; + arity = Number.parseInt(arity, 10); + if (Number.isNaN(arity) || arity < 1) { + arity = 0; + } + const wrapper = function (...partialArgs) { + const holders = partialArgs.filter(item => item === curry.placeholder); + const length = partialArgs.length - holders.length; + if (length < arity) { + return makeCurry(func, arity - length, partialArgs); + } + if (this instanceof wrapper) { + return new func(...partialArgs); + } + return func.apply(this, partialArgs); + }; + wrapper.placeholder = curryPlaceholder; + return wrapper; +} +function makeCurry(func, arity, partialArgs) { + function wrapper(...providedArgs) { + const holders = providedArgs.filter(item => item === curry.placeholder); + const length = providedArgs.length - holders.length; + providedArgs = composeArgs(providedArgs, partialArgs); + if (length < arity) { + return makeCurry(func, arity - length, providedArgs); + } + if (this instanceof wrapper) { + return new func(...providedArgs); + } + return func.apply(this, providedArgs); + } + wrapper.placeholder = curryPlaceholder; + return wrapper; +} +function composeArgs(providedArgs, partialArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === curry.placeholder && startIndex < providedArgs.length) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + return args; +} +const curryPlaceholder = Symbol('curry.placeholder'); +curry.placeholder = curryPlaceholder; + +export { curry }; Index: node_modules/es-toolkit/dist/compat/function/curryRight.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/curryRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/curryRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,85 @@ +type __ = typeof curryRightPlaceholder; +interface RightCurriedFunction1 { + (): RightCurriedFunction1; + (t1: T1): R; +} +interface RightCurriedFunction2 { + (): RightCurriedFunction2; + (t2: T2): RightCurriedFunction1; + (t1: T1, t2: __): RightCurriedFunction1; + (t1: T1, t2: T2): R; +} +interface RightCurriedFunction3 { + (): RightCurriedFunction3; + (t3: T3): RightCurriedFunction2; + (t2: T2, t3: __): RightCurriedFunction2; + (t2: T2, t3: T3): RightCurriedFunction1; + (t1: T1, t2: __, t3: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; +} +interface RightCurriedFunction4 { + (): RightCurriedFunction4; + (t4: T4): RightCurriedFunction3; + (t3: T3, t4: __): RightCurriedFunction3; + (t3: T3, t4: T4): RightCurriedFunction2; + (t2: T2, t3: __, t4: __): RightCurriedFunction3; + (t2: T2, t3: T3, t4: __): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __): RightCurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; +} +interface RightCurriedFunction5 { + (): RightCurriedFunction5; + (t5: T5): RightCurriedFunction4; + (t4: T4, t5: __): RightCurriedFunction4; + (t4: T4, t5: T5): RightCurriedFunction3; + (t3: T3, t4: __, t5: __): RightCurriedFunction4; + (t3: T3, t4: T4, t5: __): RightCurriedFunction3; + (t3: T3, t4: __, t5: T5): RightCurriedFunction3; + (t3: T3, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t1: T1, t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t1: T1, t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; +} +declare function curryRight(func: (t1: T1) => R, arity?: number): RightCurriedFunction1; +declare function curryRight(func: (t1: T1, t2: T2) => R, arity?: number): RightCurriedFunction2; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): RightCurriedFunction3; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): RightCurriedFunction4; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): RightCurriedFunction5; +declare function curryRight(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; +declare namespace curryRight { + var placeholder: typeof curryRightPlaceholder; +} +declare const curryRightPlaceholder: unique symbol; + +export { curryRight }; Index: node_modules/es-toolkit/dist/compat/function/curryRight.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/curryRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/curryRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,85 @@ +type __ = typeof curryRightPlaceholder; +interface RightCurriedFunction1 { + (): RightCurriedFunction1; + (t1: T1): R; +} +interface RightCurriedFunction2 { + (): RightCurriedFunction2; + (t2: T2): RightCurriedFunction1; + (t1: T1, t2: __): RightCurriedFunction1; + (t1: T1, t2: T2): R; +} +interface RightCurriedFunction3 { + (): RightCurriedFunction3; + (t3: T3): RightCurriedFunction2; + (t2: T2, t3: __): RightCurriedFunction2; + (t2: T2, t3: T3): RightCurriedFunction1; + (t1: T1, t2: __, t3: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; +} +interface RightCurriedFunction4 { + (): RightCurriedFunction4; + (t4: T4): RightCurriedFunction3; + (t3: T3, t4: __): RightCurriedFunction3; + (t3: T3, t4: T4): RightCurriedFunction2; + (t2: T2, t3: __, t4: __): RightCurriedFunction3; + (t2: T2, t3: T3, t4: __): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __): RightCurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; +} +interface RightCurriedFunction5 { + (): RightCurriedFunction5; + (t5: T5): RightCurriedFunction4; + (t4: T4, t5: __): RightCurriedFunction4; + (t4: T4, t5: T5): RightCurriedFunction3; + (t3: T3, t4: __, t5: __): RightCurriedFunction4; + (t3: T3, t4: T4, t5: __): RightCurriedFunction3; + (t3: T3, t4: __, t5: T5): RightCurriedFunction3; + (t3: T3, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t1: T1, t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t1: T1, t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; +} +declare function curryRight(func: (t1: T1) => R, arity?: number): RightCurriedFunction1; +declare function curryRight(func: (t1: T1, t2: T2) => R, arity?: number): RightCurriedFunction2; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): RightCurriedFunction3; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): RightCurriedFunction4; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): RightCurriedFunction5; +declare function curryRight(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; +declare namespace curryRight { + var placeholder: typeof curryRightPlaceholder; +} +declare const curryRightPlaceholder: unique symbol; + +export { curryRight }; Index: node_modules/es-toolkit/dist/compat/function/curryRight.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/curryRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/curryRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,68 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function curryRight(func, arity = func.length, guard) { + arity = guard ? func.length : arity; + arity = Number.parseInt(arity, 10); + if (Number.isNaN(arity) || arity < 1) { + arity = 0; + } + const wrapper = function (...partialArgs) { + const holders = partialArgs.filter(item => item === curryRight.placeholder); + const length = partialArgs.length - holders.length; + if (length < arity) { + return makeCurryRight(func, arity - length, partialArgs); + } + if (this instanceof wrapper) { + return new func(...partialArgs); + } + return func.apply(this, partialArgs); + }; + wrapper.placeholder = curryRightPlaceholder; + return wrapper; +} +function makeCurryRight(func, arity, partialArgs) { + function wrapper(...providedArgs) { + const holders = providedArgs.filter(item => item === curryRight.placeholder); + const length = providedArgs.length - holders.length; + providedArgs = composeArgs(providedArgs, partialArgs); + if (length < arity) { + return makeCurryRight(func, arity - length, providedArgs); + } + if (this instanceof wrapper) { + return new func(...providedArgs); + } + return func.apply(this, providedArgs); + } + wrapper.placeholder = curryRightPlaceholder; + return wrapper; +} +function composeArgs(providedArgs, partialArgs) { + const placeholderLength = partialArgs.filter(arg => arg === curryRight.placeholder).length; + const rangeLength = Math.max(providedArgs.length - placeholderLength, 0); + const args = []; + let providedIndex = 0; + for (let i = 0; i < rangeLength; i++) { + args.push(providedArgs[providedIndex++]); + } + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === curryRight.placeholder) { + if (providedIndex < providedArgs.length) { + args.push(providedArgs[providedIndex++]); + } + else { + args.push(arg); + } + } + else { + args.push(arg); + } + } + return args; +} +const curryRightPlaceholder = Symbol('curryRight.placeholder'); +curryRight.placeholder = curryRightPlaceholder; + +exports.curryRight = curryRight; Index: node_modules/es-toolkit/dist/compat/function/curryRight.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/curryRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/curryRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,64 @@ +function curryRight(func, arity = func.length, guard) { + arity = guard ? func.length : arity; + arity = Number.parseInt(arity, 10); + if (Number.isNaN(arity) || arity < 1) { + arity = 0; + } + const wrapper = function (...partialArgs) { + const holders = partialArgs.filter(item => item === curryRight.placeholder); + const length = partialArgs.length - holders.length; + if (length < arity) { + return makeCurryRight(func, arity - length, partialArgs); + } + if (this instanceof wrapper) { + return new func(...partialArgs); + } + return func.apply(this, partialArgs); + }; + wrapper.placeholder = curryRightPlaceholder; + return wrapper; +} +function makeCurryRight(func, arity, partialArgs) { + function wrapper(...providedArgs) { + const holders = providedArgs.filter(item => item === curryRight.placeholder); + const length = providedArgs.length - holders.length; + providedArgs = composeArgs(providedArgs, partialArgs); + if (length < arity) { + return makeCurryRight(func, arity - length, providedArgs); + } + if (this instanceof wrapper) { + return new func(...providedArgs); + } + return func.apply(this, providedArgs); + } + wrapper.placeholder = curryRightPlaceholder; + return wrapper; +} +function composeArgs(providedArgs, partialArgs) { + const placeholderLength = partialArgs.filter(arg => arg === curryRight.placeholder).length; + const rangeLength = Math.max(providedArgs.length - placeholderLength, 0); + const args = []; + let providedIndex = 0; + for (let i = 0; i < rangeLength; i++) { + args.push(providedArgs[providedIndex++]); + } + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === curryRight.placeholder) { + if (providedIndex < providedArgs.length) { + args.push(providedArgs[providedIndex++]); + } + else { + args.push(arg); + } + } + else { + args.push(arg); + } + } + return args; +} +const curryRightPlaceholder = Symbol('curryRight.placeholder'); +curryRight.placeholder = curryRightPlaceholder; + +export { curryRight }; Index: node_modules/es-toolkit/dist/compat/function/debounce.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/debounce.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/debounce.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,144 @@ +interface DebounceSettings { + /** + * If `true`, the function will be invoked on the leading edge of the timeout. + * @default false + */ + leading?: boolean | undefined; + /** + * The maximum time `func` is allowed to be delayed before it's invoked. + * @default Infinity + */ + maxWait?: number | undefined; + /** + * If `true`, the function will be invoked on the trailing edge of the timeout. + * @default true + */ + trailing?: boolean | undefined; +} +interface DebounceSettingsLeading extends DebounceSettings { + leading: true; +} +interface DebouncedFunc any> { + /** + * Call the original function, but applying the debounce rules. + * + * If the debounced function can be run immediately, this calls it and returns its return + * value. + * + * Otherwise, it returns the return value of the last invocation, or undefined if the debounced + * function was not invoked yet. + */ + (...args: Parameters): ReturnType | undefined; + /** + * Throw away any pending invocation of the debounced function. + */ + cancel(): void; + /** + * If there is a pending invocation of the debounced function, invoke it immediately and return + * its return value. + * + * Otherwise, return the value from the last invocation, or undefined if the debounced function + * was never invoked. + */ + flush(): ReturnType | undefined; +} +interface DebouncedFuncLeading any> extends DebouncedFunc { + (...args: Parameters): ReturnType; + flush(): ReturnType; +} +/** + * 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. + * + * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period. + * If `leading` is true, the function runs immediately on the first call. + * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call. + * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen + * (since one debounced function call cannot trigger the function twice). + * + * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called. + * + * @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. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked. + * @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 any>(func: T, wait: number | undefined, options: DebounceSettingsLeading): DebouncedFuncLeading; +/** + * 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. + * + * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period. + * If `leading` is true, the function runs immediately on the first call. + * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call. + * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen + * (since one debounced function call cannot trigger the function twice). + * + * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called. + * + * @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. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked. + * @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 any>(func: T, wait?: number, options?: DebounceSettings): DebouncedFunc; + +export { type DebouncedFunc, type DebouncedFuncLeading, debounce }; Index: node_modules/es-toolkit/dist/compat/function/debounce.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/debounce.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/debounce.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,144 @@ +interface DebounceSettings { + /** + * If `true`, the function will be invoked on the leading edge of the timeout. + * @default false + */ + leading?: boolean | undefined; + /** + * The maximum time `func` is allowed to be delayed before it's invoked. + * @default Infinity + */ + maxWait?: number | undefined; + /** + * If `true`, the function will be invoked on the trailing edge of the timeout. + * @default true + */ + trailing?: boolean | undefined; +} +interface DebounceSettingsLeading extends DebounceSettings { + leading: true; +} +interface DebouncedFunc any> { + /** + * Call the original function, but applying the debounce rules. + * + * If the debounced function can be run immediately, this calls it and returns its return + * value. + * + * Otherwise, it returns the return value of the last invocation, or undefined if the debounced + * function was not invoked yet. + */ + (...args: Parameters): ReturnType | undefined; + /** + * Throw away any pending invocation of the debounced function. + */ + cancel(): void; + /** + * If there is a pending invocation of the debounced function, invoke it immediately and return + * its return value. + * + * Otherwise, return the value from the last invocation, or undefined if the debounced function + * was never invoked. + */ + flush(): ReturnType | undefined; +} +interface DebouncedFuncLeading any> extends DebouncedFunc { + (...args: Parameters): ReturnType; + flush(): ReturnType; +} +/** + * 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. + * + * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period. + * If `leading` is true, the function runs immediately on the first call. + * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call. + * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen + * (since one debounced function call cannot trigger the function twice). + * + * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called. + * + * @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. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked. + * @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 any>(func: T, wait: number | undefined, options: DebounceSettingsLeading): DebouncedFuncLeading; +/** + * 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. + * + * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period. + * If `leading` is true, the function runs immediately on the first call. + * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call. + * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen + * (since one debounced function call cannot trigger the function twice). + * + * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called. + * + * @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. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked. + * @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 any>(func: T, wait?: number, options?: DebounceSettings): DebouncedFunc; + +export { type DebouncedFunc, type DebouncedFuncLeading, debounce }; Index: node_modules/es-toolkit/dist/compat/function/debounce.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/debounce.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/debounce.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,50 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const debounce$1 = require('../../function/debounce.js'); + +function debounce(func, debounceMs = 0, options = {}) { + if (typeof options !== 'object') { + options = {}; + } + const { leading = false, trailing = true, maxWait } = options; + const edges = Array(2); + if (leading) { + edges[0] = 'leading'; + } + if (trailing) { + edges[1] = 'trailing'; + } + let result = undefined; + let pendingAt = null; + const _debounced = debounce$1.debounce(function (...args) { + result = func.apply(this, args); + pendingAt = null; + }, debounceMs, { edges }); + const debounced = function (...args) { + if (maxWait != null) { + if (pendingAt === null) { + pendingAt = Date.now(); + } + if (Date.now() - pendingAt >= maxWait) { + result = func.apply(this, args); + pendingAt = Date.now(); + _debounced.cancel(); + _debounced.schedule(); + return result; + } + } + _debounced.apply(this, args); + return result; + }; + const flush = () => { + _debounced.flush(); + return result; + }; + debounced.cancel = _debounced.cancel; + debounced.flush = flush; + return debounced; +} + +exports.debounce = debounce; Index: node_modules/es-toolkit/dist/compat/function/debounce.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/debounce.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/debounce.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,46 @@ +import { debounce as debounce$1 } from '../../function/debounce.mjs'; + +function debounce(func, debounceMs = 0, options = {}) { + if (typeof options !== 'object') { + options = {}; + } + const { leading = false, trailing = true, maxWait } = options; + const edges = Array(2); + if (leading) { + edges[0] = 'leading'; + } + if (trailing) { + edges[1] = 'trailing'; + } + let result = undefined; + let pendingAt = null; + const _debounced = debounce$1(function (...args) { + result = func.apply(this, args); + pendingAt = null; + }, debounceMs, { edges }); + const debounced = function (...args) { + if (maxWait != null) { + if (pendingAt === null) { + pendingAt = Date.now(); + } + if (Date.now() - pendingAt >= maxWait) { + result = func.apply(this, args); + pendingAt = Date.now(); + _debounced.cancel(); + _debounced.schedule(); + return result; + } + } + _debounced.apply(this, args); + return result; + }; + const flush = () => { + _debounced.flush(); + return result; + }; + debounced.cancel = _debounced.cancel; + debounced.flush = flush; + return debounced; +} + +export { debounce }; Index: node_modules/es-toolkit/dist/compat/function/defer.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/defer.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/defer.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,14 @@ +/** + * Defers invoking the `func` until the current call stack has cleared. Any additional arguments are provided to func when it's invoked. + * + * @param {(...args: any[]) => any} func The function to defer. + * @param {...any[]} args The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * + * @example + * defer(console.log, 'deferred'); + * // => Logs 'deferred' after the current call stack has cleared. + */ +declare function defer(func: (...args: any[]) => any, ...args: any[]): number; + +export { defer }; Index: node_modules/es-toolkit/dist/compat/function/defer.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/defer.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/defer.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,14 @@ +/** + * Defers invoking the `func` until the current call stack has cleared. Any additional arguments are provided to func when it's invoked. + * + * @param {(...args: any[]) => any} func The function to defer. + * @param {...any[]} args The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * + * @example + * defer(console.log, 'deferred'); + * // => Logs 'deferred' after the current call stack has cleared. + */ +declare function defer(func: (...args: any[]) => any, ...args: any[]): number; + +export { defer }; Index: node_modules/es-toolkit/dist/compat/function/defer.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/defer.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/defer.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function defer(func, ...args) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return setTimeout(func, 1, ...args); +} + +exports.defer = defer; Index: node_modules/es-toolkit/dist/compat/function/defer.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/defer.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/defer.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,8 @@ +function defer(func, ...args) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return setTimeout(func, 1, ...args); +} + +export { defer }; Index: node_modules/es-toolkit/dist/compat/function/delay.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/delay.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/delay.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,29 @@ +/** + * Invokes the specified function after a delay of the given number of milliseconds. + * Any additional arguments are passed to the function when it is invoked. + * + * @param {(...args: any[]) => any} func - The function to delay. + * @param {number} wait - The number of milliseconds to delay the invocation. + * @param {...any[]} args - The arguments to pass to the function when it is invoked. + * @returns {number} Returns the timer id. + * @throws {TypeError} If the first argument is not a function. + * + * @example + * // Example 1: Delayed function execution + * const timerId = delay( + * (greeting, recipient) => { + * console.log(`${greeting}, ${recipient}!`); + * }, + * 1000, + * 'Hello', + * 'Alice' + * ); + * // => 'Hello, Alice!' will be logged after one second. + * + * // Example 2: Clearing the timeout before execution + * clearTimeout(timerId); + * // The function will not be executed because the timeout was cleared. + */ +declare function delay(func: (...args: any[]) => any, wait: number, ...args: any[]): number; + +export { delay }; Index: node_modules/es-toolkit/dist/compat/function/delay.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/delay.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/delay.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,29 @@ +/** + * Invokes the specified function after a delay of the given number of milliseconds. + * Any additional arguments are passed to the function when it is invoked. + * + * @param {(...args: any[]) => any} func - The function to delay. + * @param {number} wait - The number of milliseconds to delay the invocation. + * @param {...any[]} args - The arguments to pass to the function when it is invoked. + * @returns {number} Returns the timer id. + * @throws {TypeError} If the first argument is not a function. + * + * @example + * // Example 1: Delayed function execution + * const timerId = delay( + * (greeting, recipient) => { + * console.log(`${greeting}, ${recipient}!`); + * }, + * 1000, + * 'Hello', + * 'Alice' + * ); + * // => 'Hello, Alice!' will be logged after one second. + * + * // Example 2: Clearing the timeout before execution + * clearTimeout(timerId); + * // The function will not be executed because the timeout was cleared. + */ +declare function delay(func: (...args: any[]) => any, wait: number, ...args: any[]): number; + +export { delay }; Index: node_modules/es-toolkit/dist/compat/function/delay.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/delay.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/delay.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('../util/toNumber.js'); + +function delay(func, wait, ...args) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return setTimeout(func, toNumber.toNumber(wait) || 0, ...args); +} + +exports.delay = delay; Index: node_modules/es-toolkit/dist/compat/function/delay.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/delay.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/delay.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,10 @@ +import { toNumber } from '../util/toNumber.mjs'; + +function delay(func, wait, ...args) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return setTimeout(func, toNumber(wait) || 0, ...args); +} + +export { delay }; Index: node_modules/es-toolkit/dist/compat/function/flip.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/flip.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flip.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +/** + * Reverses the order of arguments for a given function. + * + * @template T - The type of the function being flipped. + * @param {T} func - The function whose arguments will be reversed. + * @returns {T} A new function that takes the reversed arguments and returns the result of calling `func`. + * + * @example + * var flipped = flip(function() { + * return Array.prototype.slice.call(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ +declare function flip any>(func: T): T; + +export { flip }; Index: node_modules/es-toolkit/dist/compat/function/flip.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/flip.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flip.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +/** + * Reverses the order of arguments for a given function. + * + * @template T - The type of the function being flipped. + * @param {T} func - The function whose arguments will be reversed. + * @returns {T} A new function that takes the reversed arguments and returns the result of calling `func`. + * + * @example + * var flipped = flip(function() { + * return Array.prototype.slice.call(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ +declare function flip any>(func: T): T; + +export { flip }; Index: node_modules/es-toolkit/dist/compat/function/flip.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/flip.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flip.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function flip(func) { + return function (...args) { + return func.apply(this, args.reverse()); + }; +} + +exports.flip = flip; Index: node_modules/es-toolkit/dist/compat/function/flip.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/flip.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flip.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +function flip(func) { + return function (...args) { + return func.apply(this, args.reverse()); + }; +} + +export { flip }; Index: node_modules/es-toolkit/dist/compat/function/flow.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/flow.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flow.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,119 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * 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. + * + * @template A - The type of the arguments. + * @template R - The type of the return values. + * @param {(...args: A) => R} f1 - The first function to invoke. + * @param {(a: R) => R} f2 - The second function to invoke. + * @param {(a: R) => R} f3 - The third function to invoke. + * @param {(a: R) => R} f4 - The fourth function to invoke. + * @param {(a: R) => R} f5 - The fifth function to invoke. + * @param {(a: R) => R} f6 - The sixth function to invoke. + * @param {(a: R) => R} f7 - The seventh function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function square(n) { + * return n * n; + * } + * + * var addSquare = flow([add, square]); + * addSquare(1, 2); + * // => 9 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (...args: A) => R7; +/** + * Creates a new function that executes up to 7 functions in sequence, with additional functions flattened. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => n.toString(); + * + * const combined = flow(add, square, double, toString); + * 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, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): (...args: A) => any; +/** + * Creates a new function that executes 6 functions in sequence. + * The return value of each function is passed as an argument to the next 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, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: A) => R6; +/** + * Creates a new function that executes 5 functions in sequence. + * The return value of each function is passed as an argument to the next 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, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5; +/** + * Creates a new function that executes 4 functions in sequence. + * The return value of each function is passed as an argument to the next 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, f4: (a: R3) => R4): (...args: A) => R4; +/** + * Creates a new function that executes 3 functions in sequence. + * The return value of each function is passed as an argument to the next 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 2 functions in sequence. + * The return value of the first function is passed as an argument to the second function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const addThenSquare = flow(add, square); + * console.log(addThenSquare(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 each function is passed as an argument to the next 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(...func: Array any>>): (...args: any[]) => any; + +export { flow }; Index: node_modules/es-toolkit/dist/compat/function/flow.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/flow.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flow.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,119 @@ +import { Many } from '../_internal/Many.js'; + +/** + * 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. + * + * @template A - The type of the arguments. + * @template R - The type of the return values. + * @param {(...args: A) => R} f1 - The first function to invoke. + * @param {(a: R) => R} f2 - The second function to invoke. + * @param {(a: R) => R} f3 - The third function to invoke. + * @param {(a: R) => R} f4 - The fourth function to invoke. + * @param {(a: R) => R} f5 - The fifth function to invoke. + * @param {(a: R) => R} f6 - The sixth function to invoke. + * @param {(a: R) => R} f7 - The seventh function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function square(n) { + * return n * n; + * } + * + * var addSquare = flow([add, square]); + * addSquare(1, 2); + * // => 9 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (...args: A) => R7; +/** + * Creates a new function that executes up to 7 functions in sequence, with additional functions flattened. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => n.toString(); + * + * const combined = flow(add, square, double, toString); + * 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, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): (...args: A) => any; +/** + * Creates a new function that executes 6 functions in sequence. + * The return value of each function is passed as an argument to the next 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, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: A) => R6; +/** + * Creates a new function that executes 5 functions in sequence. + * The return value of each function is passed as an argument to the next 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, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5; +/** + * Creates a new function that executes 4 functions in sequence. + * The return value of each function is passed as an argument to the next 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, f4: (a: R3) => R4): (...args: A) => R4; +/** + * Creates a new function that executes 3 functions in sequence. + * The return value of each function is passed as an argument to the next 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 2 functions in sequence. + * The return value of the first function is passed as an argument to the second function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const addThenSquare = flow(add, square); + * console.log(addThenSquare(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 each function is passed as an argument to the next 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(...func: Array any>>): (...args: any[]) => any; + +export { flow }; Index: node_modules/es-toolkit/dist/compat/function/flow.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/flow.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flow.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('../../array/flatten.js'); +const flow$1 = require('../../function/flow.js'); + +function flow(...funcs) { + const flattenFuncs = flatten.flatten(funcs, 1); + if (flattenFuncs.some(func => typeof func !== 'function')) { + throw new TypeError('Expected a function'); + } + return flow$1.flow(...flattenFuncs); +} + +exports.flow = flow; Index: node_modules/es-toolkit/dist/compat/function/flow.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/flow.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flow.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +import { flatten } from '../../array/flatten.mjs'; +import { flow as flow$1 } from '../../function/flow.mjs'; + +function flow(...funcs) { + const flattenFuncs = flatten(funcs, 1); + if (flattenFuncs.some(func => typeof func !== 'function')) { + throw new TypeError('Expected a function'); + } + return flow$1(...flattenFuncs); +} + +export { flow }; Index: node_modules/es-toolkit/dist/compat/function/flowRight.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/flowRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flowRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,117 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * 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. + * + * @template A - The type of the arguments. + * @template R - The type of the return values. + * @param {(a: R) => R} f7 - The seventh function to invoke. + * @param {(a: R) => R} f6 - The sixth function to invoke. + * @param {(a: R) => R} f5 - The fifth function to invoke. + * @param {(a: R) => R} f4 - The fourth function to invoke. + * @param {(a: R) => R} f3 - The third function to invoke. + * @param {(a: R) => R} f2 - The second function to invoke. + * @param {(...args: A) => R} f1 - The first function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function square(n) { + * return n * n; + * } + * + * var addSquare = flowRight(square, add); + * addSquare(1, 2); + * // => 9 + */ +declare function flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R7; +/** + * Creates a new function that executes 6 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * const append = (s: string) => s + '!'; + * const length = (s: string) => s.length; + * + * const combined = flowRight(length, append, toString, double, square, add); + * console.log(combined(1, 2)); // 7 + */ +declare function flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R6; +/** + * Creates a new function that executes 5 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * const append = (s: string) => s + '!'; + * + * const combined = flowRight(append, toString, double, square, add); + * console.log(combined(1, 2)); // '18!' + */ +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 4 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * + * const combined = flowRight(toString, 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 3 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next 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 2 functions in sequence from right to left. + * The return value of the first function is passed as an argument to the second 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 each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * + * // Pass functions as separate arguments + * const combined1 = flowRight(toString, double, square, add); + * console.log(combined1(1, 2)); // '18' + * + * // Pass functions as arrays + * const combined2 = flowRight([toString, double], [square, add]); + * console.log(combined2(1, 2)); // '18' + */ +declare function flowRight(...func: Array any>>): (...args: any[]) => any; + +export { flowRight }; Index: node_modules/es-toolkit/dist/compat/function/flowRight.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/flowRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flowRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,117 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function. + * + * @template A - The type of the arguments. + * @template R - The type of the return values. + * @param {(a: R) => R} f7 - The seventh function to invoke. + * @param {(a: R) => R} f6 - The sixth function to invoke. + * @param {(a: R) => R} f5 - The fifth function to invoke. + * @param {(a: R) => R} f4 - The fourth function to invoke. + * @param {(a: R) => R} f3 - The third function to invoke. + * @param {(a: R) => R} f2 - The second function to invoke. + * @param {(...args: A) => R} f1 - The first function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function square(n) { + * return n * n; + * } + * + * var addSquare = flowRight(square, add); + * addSquare(1, 2); + * // => 9 + */ +declare function flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R7; +/** + * Creates a new function that executes 6 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * const append = (s: string) => s + '!'; + * const length = (s: string) => s.length; + * + * const combined = flowRight(length, append, toString, double, square, add); + * console.log(combined(1, 2)); // 7 + */ +declare function flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R6; +/** + * Creates a new function that executes 5 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * const append = (s: string) => s + '!'; + * + * const combined = flowRight(append, toString, double, square, add); + * console.log(combined(1, 2)); // '18!' + */ +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 4 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * + * const combined = flowRight(toString, 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 3 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next 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 2 functions in sequence from right to left. + * The return value of the first function is passed as an argument to the second 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 each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * + * // Pass functions as separate arguments + * const combined1 = flowRight(toString, double, square, add); + * console.log(combined1(1, 2)); // '18' + * + * // Pass functions as arrays + * const combined2 = flowRight([toString, double], [square, add]); + * console.log(combined2(1, 2)); // '18' + */ +declare function flowRight(...func: Array any>>): (...args: any[]) => any; + +export { flowRight }; Index: node_modules/es-toolkit/dist/compat/function/flowRight.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/flowRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flowRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('../../array/flatten.js'); +const flowRight$1 = require('../../function/flowRight.js'); + +function flowRight(...funcs) { + const flattenFuncs = flatten.flatten(funcs, 1); + if (flattenFuncs.some(func => typeof func !== 'function')) { + throw new TypeError('Expected a function'); + } + return flowRight$1.flowRight(...flattenFuncs); +} + +exports.flowRight = flowRight; Index: node_modules/es-toolkit/dist/compat/function/flowRight.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/flowRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/flowRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +import { flatten } from '../../array/flatten.mjs'; +import { flowRight as flowRight$1 } from '../../function/flowRight.mjs'; + +function flowRight(...funcs) { + const flattenFuncs = flatten(funcs, 1); + if (flattenFuncs.some(func => typeof func !== 'function')) { + throw new TypeError('Expected a function'); + } + return flowRight$1(...flattenFuncs); +} + +export { flowRight }; Index: node_modules/es-toolkit/dist/compat/function/identity.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/identity.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/identity.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,42 @@ +/** + * 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(value: T): T; +/** + * 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(): undefined; + +export { identity }; Index: node_modules/es-toolkit/dist/compat/function/identity.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/identity.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/identity.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,42 @@ +/** + * 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(value: T): T; +/** + * 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(): undefined; + +export { identity }; Index: node_modules/es-toolkit/dist/compat/function/identity.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/identity.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/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/compat/function/identity.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/identity.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/identity.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,5 @@ +function identity(x) { + return x; +} + +export { identity }; Index: node_modules/es-toolkit/dist/compat/function/memoize.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/memoize.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/memoize.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,119 @@ +interface MapCache { + /** + * Removes the value associated with the specified key from the cache. + * + * @param key - The key of the value to remove + * @returns `true` if an element was removed, `false` if the key wasn't found + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.delete('user'); // Returns true + * cache.delete('unknown'); // Returns false + * ``` + */ + delete(key: any): boolean; + /** + * Retrieves the value associated with the specified key from the cache. + * + * @param key - The key of the value to retrieve + * @returns The cached value or undefined if not found + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.get('user'); // Returns { id: 123, name: 'John' } + * cache.get('unknown'); // Returns undefined + * ``` + */ + get(key: any): any; + /** + * Checks if the cache contains a value for the specified key. + * + * @param key - The key to check for existence + * @returns `true` if the key exists in the cache, otherwise `false` + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.has('user'); // Returns true + * cache.has('unknown'); // Returns false + * ``` + */ + has(key: any): boolean; + /** + * Stores a value in the cache with the specified key. + * If the key already exists, its value is updated. + * + * @param key - The key to associate with the value + * @param value - The value to store in the cache + * @returns The cache instance for method chaining + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }) + * .set('settings', { theme: 'dark' }); + * ``` + */ + set(key: any, value: any): this; + /** + * Removes all key-value pairs from the cache. + * This method is optional as some cache implementations may be immutable. + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.set('settings', { theme: 'dark' }); + * cache.clear(); // Cache is now empty + * ``` + */ + clear?(): void; +} +/** + * Constructor interface for creating a new MapCache instance. + * This defines the shape of a constructor that can create cache objects + * conforming to the MapCache interface. + * + * @example + * ```typescript + * class CustomCache implements MapCache { + * // Cache implementation + * } + * + * const CacheConstructor: MapCacheConstructor = CustomCache; + * const cache = new CacheConstructor(); + * ``` + */ +interface MapCacheConstructor { + new (): MapCache; +} +/** + * Represents a function that has been memoized. + * A memoized function maintains the same signature as the original function + * but adds a cache property to store previously computed results. + * + * @template T - The type of the original function being memoized + */ +interface MemoizedFunction { + /** + * The cache storing previously computed results + */ + cache: MapCache; +} +/** + * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for + * storing the result based on the arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with + * the this binding of the memoized function. + * + * @template T - The type of the original function being memoized + * @param {T} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @return {MemoizedFunction} Returns the new memoizing function. + */ +declare function memoize any>(func: T, resolver?: (...args: Parameters) => any): T & MemoizedFunction; +declare namespace memoize { + var Cache: MapCacheConstructor; +} + +export { memoize }; Index: node_modules/es-toolkit/dist/compat/function/memoize.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/memoize.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/memoize.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,119 @@ +interface MapCache { + /** + * Removes the value associated with the specified key from the cache. + * + * @param key - The key of the value to remove + * @returns `true` if an element was removed, `false` if the key wasn't found + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.delete('user'); // Returns true + * cache.delete('unknown'); // Returns false + * ``` + */ + delete(key: any): boolean; + /** + * Retrieves the value associated with the specified key from the cache. + * + * @param key - The key of the value to retrieve + * @returns The cached value or undefined if not found + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.get('user'); // Returns { id: 123, name: 'John' } + * cache.get('unknown'); // Returns undefined + * ``` + */ + get(key: any): any; + /** + * Checks if the cache contains a value for the specified key. + * + * @param key - The key to check for existence + * @returns `true` if the key exists in the cache, otherwise `false` + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.has('user'); // Returns true + * cache.has('unknown'); // Returns false + * ``` + */ + has(key: any): boolean; + /** + * Stores a value in the cache with the specified key. + * If the key already exists, its value is updated. + * + * @param key - The key to associate with the value + * @param value - The value to store in the cache + * @returns The cache instance for method chaining + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }) + * .set('settings', { theme: 'dark' }); + * ``` + */ + set(key: any, value: any): this; + /** + * Removes all key-value pairs from the cache. + * This method is optional as some cache implementations may be immutable. + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.set('settings', { theme: 'dark' }); + * cache.clear(); // Cache is now empty + * ``` + */ + clear?(): void; +} +/** + * Constructor interface for creating a new MapCache instance. + * This defines the shape of a constructor that can create cache objects + * conforming to the MapCache interface. + * + * @example + * ```typescript + * class CustomCache implements MapCache { + * // Cache implementation + * } + * + * const CacheConstructor: MapCacheConstructor = CustomCache; + * const cache = new CacheConstructor(); + * ``` + */ +interface MapCacheConstructor { + new (): MapCache; +} +/** + * Represents a function that has been memoized. + * A memoized function maintains the same signature as the original function + * but adds a cache property to store previously computed results. + * + * @template T - The type of the original function being memoized + */ +interface MemoizedFunction { + /** + * The cache storing previously computed results + */ + cache: MapCache; +} +/** + * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for + * storing the result based on the arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with + * the this binding of the memoized function. + * + * @template T - The type of the original function being memoized + * @param {T} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @return {MemoizedFunction} Returns the new memoizing function. + */ +declare function memoize any>(func: T, resolver?: (...args: Parameters) => any): T & MemoizedFunction; +declare namespace memoize { + var Cache: MapCacheConstructor; +} + +export { memoize }; Index: node_modules/es-toolkit/dist/compat/function/memoize.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/memoize.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/memoize.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function memoize(func, resolver) { + if (typeof func !== 'function' || (resolver != null && typeof resolver !== 'function')) { + throw new TypeError('Expected a function'); + } + const memoized = function (...args) { + const key = resolver ? resolver.apply(this, args) : args[0]; + const cache = memoized.cache; + if (cache.has(key)) { + return cache.get(key); + } + const result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + const CacheConstructor = memoize.Cache || Map; + memoized.cache = new CacheConstructor(); + return memoized; +} +memoize.Cache = Map; + +exports.memoize = memoize; Index: node_modules/es-toolkit/dist/compat/function/memoize.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/memoize.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/memoize.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,21 @@ +function memoize(func, resolver) { + if (typeof func !== 'function' || (resolver != null && typeof resolver !== 'function')) { + throw new TypeError('Expected a function'); + } + const memoized = function (...args) { + const key = resolver ? resolver.apply(this, args) : args[0]; + const cache = memoized.cache; + if (cache.has(key)) { + return cache.get(key); + } + const result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + const CacheConstructor = memoize.Cache || Map; + memoized.cache = new CacheConstructor(); + return memoized; +} +memoize.Cache = Map; + +export { memoize }; Index: node_modules/es-toolkit/dist/compat/function/negate.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/negate.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/negate.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +/** + * Creates a function that negates the result of the predicate function. + * + * @template T - The type of the arguments array. + * @param {(...args: T) => boolean} predicate - The predicate to negate. + * @returns {(...args: T) => boolean} The new negated function. + * + * @example + * function isEven(n) { + * return n % 2 == 0; + * } + * + * filter([1, 2, 3, 4, 5, 6], negate(isEven)); + * // => [1, 3, 5] + */ +declare function negate(predicate: (...args: T) => boolean): (...args: T) => boolean; + +export { negate }; Index: node_modules/es-toolkit/dist/compat/function/negate.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/negate.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/negate.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +/** + * Creates a function that negates the result of the predicate function. + * + * @template T - The type of the arguments array. + * @param {(...args: T) => boolean} predicate - The predicate to negate. + * @returns {(...args: T) => boolean} The new negated function. + * + * @example + * function isEven(n) { + * return n % 2 == 0; + * } + * + * filter([1, 2, 3, 4, 5, 6], negate(isEven)); + * // => [1, 3, 5] + */ +declare function negate(predicate: (...args: T) => boolean): (...args: T) => boolean; + +export { negate }; Index: node_modules/es-toolkit/dist/compat/function/negate.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/negate.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/negate.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function negate(func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return function (...args) { + return !func.apply(this, args); + }; +} + +exports.negate = negate; Index: node_modules/es-toolkit/dist/compat/function/negate.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/negate.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/negate.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,10 @@ +function negate(func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return function (...args) { + return !func.apply(this, args); + }; +} + +export { negate }; Index: node_modules/es-toolkit/dist/compat/function/noop.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/noop.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/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(..._: any[]): void; + +export { noop }; Index: node_modules/es-toolkit/dist/compat/function/noop.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/noop.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/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(..._: any[]): void; + +export { noop }; Index: node_modules/es-toolkit/dist/compat/function/noop.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/noop.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/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/compat/function/noop.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/noop.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/noop.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,3 @@ +function noop(..._) { } + +export { noop }; Index: node_modules/es-toolkit/dist/compat/function/nthArg.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/nthArg.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/nthArg.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +/** + * Creates a function that gets the argument at index `n`. If `n` is negative, the nth argument from the end is returned. + * + * @param {number} [n=0] - The index of the argument to return. + * @returns {(...args: any[]) => any} Returns the new function. + * + * @example + * var func = nthArg(1); + * func('a', 'b', 'c', 'd'); + * // => 'b' + * + * var func = nthArg(-2); + * func('a', 'b', 'c', 'd'); + * // => 'c' + */ +declare function nthArg(n?: number): (...args: any[]) => any; + +export { nthArg }; Index: node_modules/es-toolkit/dist/compat/function/nthArg.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/nthArg.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/nthArg.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +/** + * Creates a function that gets the argument at index `n`. If `n` is negative, the nth argument from the end is returned. + * + * @param {number} [n=0] - The index of the argument to return. + * @returns {(...args: any[]) => any} Returns the new function. + * + * @example + * var func = nthArg(1); + * func('a', 'b', 'c', 'd'); + * // => 'b' + * + * var func = nthArg(-2); + * func('a', 'b', 'c', 'd'); + * // => 'c' + */ +declare function nthArg(n?: number): (...args: any[]) => any; + +export { nthArg }; Index: node_modules/es-toolkit/dist/compat/function/nthArg.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/nthArg.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/nthArg.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('../util/toInteger.js'); + +function nthArg(n = 0) { + return function (...args) { + return args.at(toInteger.toInteger(n)); + }; +} + +exports.nthArg = nthArg; Index: node_modules/es-toolkit/dist/compat/function/nthArg.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/nthArg.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/nthArg.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,9 @@ +import { toInteger } from '../util/toInteger.mjs'; + +function nthArg(n = 0) { + return function (...args) { + return args.at(toInteger(n)); + }; +} + +export { nthArg }; Index: node_modules/es-toolkit/dist/compat/function/once.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/once.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/once.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,3 @@ +declare function once any>(func: T): T; + +export { once }; Index: node_modules/es-toolkit/dist/compat/function/once.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/once.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/once.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,3 @@ +declare function once any>(func: T): T; + +export { once }; Index: node_modules/es-toolkit/dist/compat/function/once.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/once.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/once.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const once$1 = require('../../function/once.js'); + +function once(func) { + return once$1.once(func); +} + +exports.once = once; Index: node_modules/es-toolkit/dist/compat/function/once.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/once.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/once.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +import { once as once$1 } from '../../function/once.mjs'; + +function once(func) { + return once$1(func); +} + +export { once }; Index: node_modules/es-toolkit/dist/compat/function/overArgs.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/overArgs.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/overArgs.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,50 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Creates a function that invokes `func` with its arguments transformed by corresponding transform functions. + * + * Transform functions can be: + * - Functions that accept and return a value + * - Property names (strings) to get a property value from each argument + * - Objects to check if arguments match the object properties + * - Arrays of [property, value] to check if argument properties match values + * + * If a transform is nullish, the identity function is used instead. + * Only transforms arguments up to the number of transform functions provided. + * + * @param {(...args: any[]) => any} func - The function to wrap + * @param {Array any>>} transforms - The functions to transform arguments. Each transform can be: + * - A function that accepts and returns a value + * - A string to get a property value (e.g. 'name' gets the name property) + * - An object to check if arguments match its properties + * - An array of [property, value] to check property matches + * @returns {(...args: any[]) => any} A new function that transforms arguments before passing them to func + * @throws {TypeError} If func is not a function. + * @example + * ```ts + * function doubled(n: number) { + * return n * 2; + * } + * + * function square(n: number) { + * return n * n; + * } + * + * const func = overArgs((x, y) => [x, y], [doubled, square]); + * + * func(5, 3); + * // => [10, 9] + * + * // With property shorthand + * const user = { name: 'John', age: 30 }; + * const getUserInfo = overArgs( + * (name, age) => `${name} is ${age} years old`, + * ['name', 'age'] + * ); + * getUserInfo(user, user); + * // => "John is 30 years old" + * ``` + */ +declare function overArgs(func: (...args: any[]) => any, ..._transforms: Array any>>): (...args: any[]) => any; + +export { overArgs }; Index: node_modules/es-toolkit/dist/compat/function/overArgs.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/overArgs.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/overArgs.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,50 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Creates a function that invokes `func` with its arguments transformed by corresponding transform functions. + * + * Transform functions can be: + * - Functions that accept and return a value + * - Property names (strings) to get a property value from each argument + * - Objects to check if arguments match the object properties + * - Arrays of [property, value] to check if argument properties match values + * + * If a transform is nullish, the identity function is used instead. + * Only transforms arguments up to the number of transform functions provided. + * + * @param {(...args: any[]) => any} func - The function to wrap + * @param {Array any>>} transforms - The functions to transform arguments. Each transform can be: + * - A function that accepts and returns a value + * - A string to get a property value (e.g. 'name' gets the name property) + * - An object to check if arguments match its properties + * - An array of [property, value] to check property matches + * @returns {(...args: any[]) => any} A new function that transforms arguments before passing them to func + * @throws {TypeError} If func is not a function. + * @example + * ```ts + * function doubled(n: number) { + * return n * 2; + * } + * + * function square(n: number) { + * return n * n; + * } + * + * const func = overArgs((x, y) => [x, y], [doubled, square]); + * + * func(5, 3); + * // => [10, 9] + * + * // With property shorthand + * const user = { name: 'John', age: 30 }; + * const getUserInfo = overArgs( + * (name, age) => `${name} is ${age} years old`, + * ['name', 'age'] + * ); + * getUserInfo(user, user); + * // => "John is 30 years old" + * ``` + */ +declare function overArgs(func: (...args: any[]) => any, ..._transforms: Array any>>): (...args: any[]) => any; + +export { overArgs }; Index: node_modules/es-toolkit/dist/compat/function/overArgs.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/overArgs.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/overArgs.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const iteratee = require('../util/iteratee.js'); + +function overArgs(func, ..._transforms) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + const transforms = _transforms.flat(); + return function (...args) { + const length = Math.min(args.length, transforms.length); + const transformedArgs = [...args]; + for (let i = 0; i < length; i++) { + const transform = iteratee.iteratee(transforms[i] ?? identity.identity); + transformedArgs[i] = transform.call(this, args[i]); + } + return func.apply(this, transformedArgs); + }; +} + +exports.overArgs = overArgs; Index: node_modules/es-toolkit/dist/compat/function/overArgs.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/overArgs.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/overArgs.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,20 @@ +import { identity } from '../../function/identity.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function overArgs(func, ..._transforms) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + const transforms = _transforms.flat(); + return function (...args) { + const length = Math.min(args.length, transforms.length); + const transformedArgs = [...args]; + for (let i = 0; i < length; i++) { + const transform = iteratee(transforms[i] ?? identity); + transformedArgs[i] = transform.call(this, args[i]); + } + return func.apply(this, transformedArgs); + }; +} + +export { overArgs }; Index: node_modules/es-toolkit/dist/compat/function/partial.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/partial.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/partial.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,204 @@ +import { Toolkit } from '../toolkit.mjs'; + +type __ = Placeholder | Toolkit; +/** + * 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. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}`; + * const sayHello = partial(greet, _, 'world'); + * console.log(sayHello('Hello')); // => 'Hello world' + */ +declare function partial(func: (t1: T1, t2: T2) => R, plc1: __, arg2: T2): (t1: 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. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const addToY = partial(calculate, _, 2); + * console.log(addToY(1, 3)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, arg2: T2): (t1: T1, t3: 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. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const addZ = partial(calculate, _, _, 3); + * console.log(addZ(1, 2)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, plc2: __, arg3: T3): (t1: T1, t2: 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. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const withXandZ = partial(calculate, 1, _, 3); + * console.log(withXandZ(2)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, arg3: T3): (t2: 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. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const withYandZ = partial(calculate, _, 2, 3); + * console.log(withYandZ(1)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, arg2: T2, arg3: T3): (t1: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withB = partial(format, _, 'b'); + * console.log(withB('a', 'c', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2): (t1: T1, t3: T3, t4: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withC = partial(format, _, _, 'c'); + * console.log(withC('a', 'b', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, arg3: T3): (t1: T1, t2: T2, t4: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withAandC = partial(format, 'a', _, 'c'); + * console.log(withAandC('b', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2, t4: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBandC = partial(format, _, 'b', 'c'); + * console.log(withBandC('a', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, arg3: T3): (t1: T1, t4: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withD = partial(format, _, _, _, 'd'); + * console.log(withD('a', 'b', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, plc3: __, arg4: T4): (t1: T1, t2: T2, t3: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withAandD = partial(format, 'a', _, _, 'd'); + * console.log(withAandD('b', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, arg4: T4): (t2: T2, t3: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBandD = partial(format, _, 'b', _, 'd'); + * console.log(withBandD('a', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, plc3: __, arg4: T4): (t1: T1, t3: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withABandD = partial(format, 'a', 'b', _, 'd'); + * console.log(withABandD('c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, arg4: T4): (t3: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withCandD = partial(format, _, _, 'c', 'd'); + * console.log(withCandD('a', 'b')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, arg3: T3, arg4: T4): (t1: T1, t2: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withACandD = partial(format, 'a', _, 'c', 'd'); + * console.log(withACandD('b')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, arg4: T4): (t2: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBCandD = partial(format, _, 'b', 'c', 'd'); + * console.log(withBCandD('a')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, arg3: T3, arg4: T4): (t1: 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. + * + * @example + * const sum = (...numbers: number[]) => numbers.reduce((a, b) => a + b, 0); + * const partialSum = partial(sum); + * console.log(partialSum(1, 2, 3)); // => 6 + */ +declare function partial(func: (...ts: TS) => R): (...ts: 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. + * + * @example + * const log = (prefix: string, ...messages: string[]) => console.log(prefix, ...messages); + * const debugLog = partial(log, '[DEBUG]'); + * debugLog('message 1', 'message 2'); // => '[DEBUG] message 1 message 2' + */ +declare function partial(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: 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. + * + * @example + * const format = (prefix: string, separator: string, ...messages: string[]) => `${prefix}${messages.join(separator)}`; + * const logWithPrefix = partial(format, '[LOG]', ' - '); + * console.log(logWithPrefix('msg1', 'msg2')); // => '[LOG]msg1 - msg2' + */ +declare function partial(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: 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. + * + * @example + * const format = (type: string, level: string, message: string, ...tags: string[]) => + * `[${type}][${level}] ${message} ${tags.join(',')}`; + * const errorLog = partial(format, 'ERROR', 'HIGH', 'Something went wrong'); + * console.log(errorLog('critical', 'urgent')); // => '[ERROR][HIGH] Something went wrong critical,urgent' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string, ...rest: string[]) => + * `${a}-${b}-${c}-${d}:${rest.join(',')}`; + * const prefixedFormat = partial(format, 'a', 'b', 'c', 'd'); + * console.log(prefixedFormat('e', 'f')); // => 'a-b-c-d:e,f' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R; +declare namespace partial { + var placeholder: Placeholder; +} +type Placeholder = symbol | (((value: any) => any) & { + partial: typeof partial; +}); + +export { partial }; Index: node_modules/es-toolkit/dist/compat/function/partial.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/partial.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/partial.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,204 @@ +import { Toolkit } from '../toolkit.js'; + +type __ = Placeholder | Toolkit; +/** + * 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. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}`; + * const sayHello = partial(greet, _, 'world'); + * console.log(sayHello('Hello')); // => 'Hello world' + */ +declare function partial(func: (t1: T1, t2: T2) => R, plc1: __, arg2: T2): (t1: 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. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const addToY = partial(calculate, _, 2); + * console.log(addToY(1, 3)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, arg2: T2): (t1: T1, t3: 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. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const addZ = partial(calculate, _, _, 3); + * console.log(addZ(1, 2)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, plc2: __, arg3: T3): (t1: T1, t2: 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. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const withXandZ = partial(calculate, 1, _, 3); + * console.log(withXandZ(2)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, arg3: T3): (t2: 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. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const withYandZ = partial(calculate, _, 2, 3); + * console.log(withYandZ(1)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, arg2: T2, arg3: T3): (t1: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withB = partial(format, _, 'b'); + * console.log(withB('a', 'c', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2): (t1: T1, t3: T3, t4: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withC = partial(format, _, _, 'c'); + * console.log(withC('a', 'b', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, arg3: T3): (t1: T1, t2: T2, t4: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withAandC = partial(format, 'a', _, 'c'); + * console.log(withAandC('b', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2, t4: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBandC = partial(format, _, 'b', 'c'); + * console.log(withBandC('a', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, arg3: T3): (t1: T1, t4: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withD = partial(format, _, _, _, 'd'); + * console.log(withD('a', 'b', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, plc3: __, arg4: T4): (t1: T1, t2: T2, t3: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withAandD = partial(format, 'a', _, _, 'd'); + * console.log(withAandD('b', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, arg4: T4): (t2: T2, t3: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBandD = partial(format, _, 'b', _, 'd'); + * console.log(withBandD('a', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, plc3: __, arg4: T4): (t1: T1, t3: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withABandD = partial(format, 'a', 'b', _, 'd'); + * console.log(withABandD('c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, arg4: T4): (t3: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withCandD = partial(format, _, _, 'c', 'd'); + * console.log(withCandD('a', 'b')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, arg3: T3, arg4: T4): (t1: T1, t2: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withACandD = partial(format, 'a', _, 'c', 'd'); + * console.log(withACandD('b')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, arg4: T4): (t2: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBCandD = partial(format, _, 'b', 'c', 'd'); + * console.log(withBCandD('a')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, arg3: T3, arg4: T4): (t1: 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. + * + * @example + * const sum = (...numbers: number[]) => numbers.reduce((a, b) => a + b, 0); + * const partialSum = partial(sum); + * console.log(partialSum(1, 2, 3)); // => 6 + */ +declare function partial(func: (...ts: TS) => R): (...ts: 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. + * + * @example + * const log = (prefix: string, ...messages: string[]) => console.log(prefix, ...messages); + * const debugLog = partial(log, '[DEBUG]'); + * debugLog('message 1', 'message 2'); // => '[DEBUG] message 1 message 2' + */ +declare function partial(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: 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. + * + * @example + * const format = (prefix: string, separator: string, ...messages: string[]) => `${prefix}${messages.join(separator)}`; + * const logWithPrefix = partial(format, '[LOG]', ' - '); + * console.log(logWithPrefix('msg1', 'msg2')); // => '[LOG]msg1 - msg2' + */ +declare function partial(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: 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. + * + * @example + * const format = (type: string, level: string, message: string, ...tags: string[]) => + * `[${type}][${level}] ${message} ${tags.join(',')}`; + * const errorLog = partial(format, 'ERROR', 'HIGH', 'Something went wrong'); + * console.log(errorLog('critical', 'urgent')); // => '[ERROR][HIGH] Something went wrong critical,urgent' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: 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. + * + * @example + * const format = (a: string, b: string, c: string, d: string, ...rest: string[]) => + * `${a}-${b}-${c}-${d}:${rest.join(',')}`; + * const prefixedFormat = partial(format, 'a', 'b', 'c', 'd'); + * console.log(prefixedFormat('e', 'f')); // => 'a-b-c-d:e,f' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R; +declare namespace partial { + var placeholder: Placeholder; +} +type Placeholder = symbol | (((value: any) => any) & { + partial: typeof partial; +}); + +export { partial }; Index: node_modules/es-toolkit/dist/compat/function/partial.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/partial.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/partial.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const partial$1 = require('../../function/partial.js'); + +function partial(func, ...partialArgs) { + return partial$1.partialImpl(func, partial.placeholder, ...partialArgs); +} +partial.placeholder = Symbol('compat.partial.placeholder'); + +exports.partial = partial; Index: node_modules/es-toolkit/dist/compat/function/partial.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/partial.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/partial.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,8 @@ +import { partialImpl } from '../../function/partial.mjs'; + +function partial(func, ...partialArgs) { + return partialImpl(func, partial.placeholder, ...partialArgs); +} +partial.placeholder = Symbol('compat.partial.placeholder'); + +export { partial }; Index: node_modules/es-toolkit/dist/compat/function/partialRight.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/partialRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/partialRight.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,622 @@ +import { Toolkit } from '../toolkit.mjs'; + +type __ = Placeholder | Toolkit; +/** + * Creates a function that invokes the provided function with no arguments. + * + * @template R The return type of the function + * @param {() => R} func The function to partially apply + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = () => 'Hello!'; + * const sayHello = partialRight(greet); + * sayHello(); // => 'Hello!' + */ +declare function partialRight(func: () => R): () => R; +/** + * Creates a function that invokes the provided function with one argument. + * + * @template T The type of the argument + * @template R The return type of the function + * @param {(t1: T) => R} func The function to partially apply + * @returns {(t1: T) => R} Returns the new partially applied function + * + * @example + * const greet = (name: string) => `Hello ${name}!`; + * const greetPerson = partialRight(greet); + * greetPerson('Fred'); // => 'Hello Fred!' + */ +declare function partialRight(func: (t1: T) => R): (t1: T) => R; +/** + * Creates a function that invokes the provided function with one argument pre-filled. + * + * @template T The type of the argument + * @template R The return type of the function + * @param {(t1: T) => R} func The function to partially apply + * @param {T} arg1 The argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (name: string) => `Hello ${name}!`; + * const greetFred = partialRight(greet, 'Fred'); + * greetFred(); // => 'Hello Fred!' + */ +declare function partialRight(func: (t1: T) => R, arg1: T): () => R; +/** + * Creates a function that invokes the provided function with two 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 {(t1: T1, t2: T2) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const greetWithParams = partialRight(greet); + * greetWithParams('Hi', 'Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with one argument pre-filled and a placeholder. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T1} arg1 The argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const hiWithName = partialRight(greet, 'Hi', partialRight.placeholder); + * hiWithName('Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg1: T1, plc2: __): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T2} arg2 The argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const greetFred = partialRight(greet, 'Fred'); + * greetFred('Hi'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg2: T2): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with both arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const sayHiToFred = partialRight(greet, 'Hi', 'Fred'); + * sayHiToFred(); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg1: T1, arg2: T2): () => R; +/** + * Creates a function that invokes the provided function with no pre-filled 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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetWithArgs = partialRight(greet); + * greetWithArgs('Hi', 'Fred', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first argument pre-filled and placeholders for the rest. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiWithNameAndPunc = partialRight(greet, 'Hi', partialRight.placeholder, partialRight.placeholder); + * hiWithNameAndPunc('Fred', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, plc3: __): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled and a placeholder for the third. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetFredWithPunc = partialRight(greet, 'Fred', partialRight.placeholder); + * greetFredWithPunc('Hi', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg2: T2, plc3: __): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first two arguments pre-filled and a placeholder for the third. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @returns {(t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiToFredWithPunc = partialRight(greet, 'Hi', 'Fred', partialRight.placeholder); + * hiToFredWithPunc('!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, arg2: T2, plc3: __): (t3: T3) => R; +/** + * Creates a function that invokes the provided function with the third argument pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetWithExclamation = partialRight(greet, '!'); + * greetWithExclamation('Hi', 'Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg3: T3): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with the first and third arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiWithNameAndExclamation = partialRight(greet, 'Hi', partialRight.placeholder, '!'); + * hiWithNameAndExclamation('Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second and third arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetFredWithExclamation = partialRight(greet, 'Fred', '!'); + * greetFredWithExclamation('Hi'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg2: T2, arg3: T3): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with all three arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const sayHiToFredWithExclamation = partialRight(greet, 'Hi', 'Fred', '!'); + * sayHiToFredWithExclamation(); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R; +/** + * Creates a function that invokes the provided function with no pre-filled 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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const formatWithArgs = partialRight(format); + * formatWithArgs('Hi', 'Fred', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): (t1: T1, t2: T2, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first argument pre-filled and placeholders for the rest. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiWithRest = partialRight(format, 'Hi', partialRight.placeholder, partialRight.placeholder, partialRight.placeholder); + * hiWithRest('Fred', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, plc4: __): (t2: T2, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled and placeholders for the rest. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredWithRest = partialRight(format, 'Fred', partialRight.placeholder, partialRight.placeholder); + * greetFredWithRest('Hi', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, plc3: __, plc4: __): (t1: T1, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first two arguments pre-filled and placeholders for the rest. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredWithRest = partialRight(format, 'Hi', 'Fred', partialRight.placeholder, partialRight.placeholder); + * hiToFredWithRest('morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, plc4: __): (t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the third argument pre-filled and a placeholder for the fourth. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t2: T2, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const atMorningWithPunc = partialRight(format, 'morning', partialRight.placeholder); + * atMorningWithPunc('Hi', 'Fred', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg3: T3, plc4: __): (t1: T1, t2: T2, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first and third arguments pre-filled and a placeholder for the fourth. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t2: T2, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiAtMorningWithNameAndPunc = partialRight(format, 'Hi', partialRight.placeholder, 'morning', partialRight.placeholder); + * hiAtMorningWithNameAndPunc('Fred', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, plc4: __): (t2: T2, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the second and third arguments pre-filled and a placeholder for the fourth. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredAtMorningWithPunc = partialRight(format, 'Fred', 'morning', partialRight.placeholder); + * greetFredAtMorningWithPunc('Hi', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, arg3: T3, plc4: __): (t1: T1, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first three arguments pre-filled and a placeholder for the fourth. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredAtMorningWithPunc = partialRight(format, 'Hi', 'Fred', 'morning', partialRight.placeholder); + * hiToFredAtMorningWithPunc('!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, arg3: T3, plc4: __): (t4: T4) => R; +/** + * Creates a function that invokes the provided function with the fourth argument pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const withExclamation = partialRight(format, '!'); + * withExclamation('Hi', 'Fred', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg4: T4): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first and fourth arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiWithExclamation = partialRight(format, 'Hi', partialRight.placeholder, partialRight.placeholder, '!'); + * hiWithExclamation('Fred', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, arg4: T4): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the second and fourth arguments pre-filled and a placeholder for the third. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredWithTime = partialRight(format, 'Fred', partialRight.placeholder, '!'); + * greetFredWithTime('Hi', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, plc3: __, arg4: T4): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first, second and fourth arguments pre-filled and a placeholder for the third. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredWithTime = partialRight(format, 'Hi', 'Fred', partialRight.placeholder, '!'); + * hiToFredWithTime('morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, arg4: T4): (t3: T3) => R; +/** + * Creates a function that invokes the provided function with the third and fourth arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const inMorningWithExclamation = partialRight(format, 'morning', '!'); + * inMorningWithExclamation('Hi', 'Fred'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg3: T3, arg4: T4): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with the first, third and fourth arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiInMorningWithExclamation = partialRight(format, 'Hi', partialRight.placeholder, 'morning', '!'); + * hiInMorningWithExclamation('Fred'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, arg4: T4): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second, third and fourth arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredInMorningWithExclamation = partialRight(format, 'Fred', 'morning', '!'); + * greetFredInMorningWithExclamation('Hi'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with all arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const sayHiToFredInMorningWithExclamation = partialRight(format, 'Hi', 'Fred', 'morning', '!'); + * sayHiToFredInMorningWithExclamation(); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R; +/** + * Creates a function that invokes the provided function with partially applied arguments appended to the arguments it receives. + * The partialRight.placeholder value can be used as a placeholder for partially applied arguments. + * + * @template F The type of the function to partially apply + * @param {F} func The function to partially apply arguments to + * @param {...any[]} args The arguments to be partially applied + * @returns {(...args: any[]) => ReturnType} Returns the new partially applied function + * + * @example + * function greet(greeting: string, name: string) { + * return greeting + ' ' + name; + * } + * + * const greetFred = partialRight(greet, 'Fred'); + * greetFred('Hi'); // => 'Hi Fred' + * + * // Using placeholders + * const sayHelloTo = partialRight(greet, 'Hello', partialRight.placeholder); + * sayHelloTo('Fred'); // => 'Hello Fred' + */ +declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; +declare namespace partialRight { + var placeholder: Placeholder; +} +type Placeholder = symbol | (((value: any) => any) & { + partialRight: typeof partialRight; +}); + +export { partialRight }; Index: node_modules/es-toolkit/dist/compat/function/partialRight.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/partialRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/partialRight.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,622 @@ +import { Toolkit } from '../toolkit.js'; + +type __ = Placeholder | Toolkit; +/** + * Creates a function that invokes the provided function with no arguments. + * + * @template R The return type of the function + * @param {() => R} func The function to partially apply + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = () => 'Hello!'; + * const sayHello = partialRight(greet); + * sayHello(); // => 'Hello!' + */ +declare function partialRight(func: () => R): () => R; +/** + * Creates a function that invokes the provided function with one argument. + * + * @template T The type of the argument + * @template R The return type of the function + * @param {(t1: T) => R} func The function to partially apply + * @returns {(t1: T) => R} Returns the new partially applied function + * + * @example + * const greet = (name: string) => `Hello ${name}!`; + * const greetPerson = partialRight(greet); + * greetPerson('Fred'); // => 'Hello Fred!' + */ +declare function partialRight(func: (t1: T) => R): (t1: T) => R; +/** + * Creates a function that invokes the provided function with one argument pre-filled. + * + * @template T The type of the argument + * @template R The return type of the function + * @param {(t1: T) => R} func The function to partially apply + * @param {T} arg1 The argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (name: string) => `Hello ${name}!`; + * const greetFred = partialRight(greet, 'Fred'); + * greetFred(); // => 'Hello Fred!' + */ +declare function partialRight(func: (t1: T) => R, arg1: T): () => R; +/** + * Creates a function that invokes the provided function with two 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 {(t1: T1, t2: T2) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const greetWithParams = partialRight(greet); + * greetWithParams('Hi', 'Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with one argument pre-filled and a placeholder. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T1} arg1 The argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const hiWithName = partialRight(greet, 'Hi', partialRight.placeholder); + * hiWithName('Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg1: T1, plc2: __): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T2} arg2 The argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const greetFred = partialRight(greet, 'Fred'); + * greetFred('Hi'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg2: T2): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with both arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const sayHiToFred = partialRight(greet, 'Hi', 'Fred'); + * sayHiToFred(); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg1: T1, arg2: T2): () => R; +/** + * Creates a function that invokes the provided function with no pre-filled 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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetWithArgs = partialRight(greet); + * greetWithArgs('Hi', 'Fred', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first argument pre-filled and placeholders for the rest. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiWithNameAndPunc = partialRight(greet, 'Hi', partialRight.placeholder, partialRight.placeholder); + * hiWithNameAndPunc('Fred', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, plc3: __): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled and a placeholder for the third. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetFredWithPunc = partialRight(greet, 'Fred', partialRight.placeholder); + * greetFredWithPunc('Hi', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg2: T2, plc3: __): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first two arguments pre-filled and a placeholder for the third. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @returns {(t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiToFredWithPunc = partialRight(greet, 'Hi', 'Fred', partialRight.placeholder); + * hiToFredWithPunc('!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, arg2: T2, plc3: __): (t3: T3) => R; +/** + * Creates a function that invokes the provided function with the third argument pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetWithExclamation = partialRight(greet, '!'); + * greetWithExclamation('Hi', 'Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg3: T3): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with the first and third arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiWithNameAndExclamation = partialRight(greet, 'Hi', partialRight.placeholder, '!'); + * hiWithNameAndExclamation('Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second and third arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetFredWithExclamation = partialRight(greet, 'Fred', '!'); + * greetFredWithExclamation('Hi'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg2: T2, arg3: T3): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with all three arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const sayHiToFredWithExclamation = partialRight(greet, 'Hi', 'Fred', '!'); + * sayHiToFredWithExclamation(); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R; +/** + * Creates a function that invokes the provided function with no pre-filled 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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const formatWithArgs = partialRight(format); + * formatWithArgs('Hi', 'Fred', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): (t1: T1, t2: T2, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first argument pre-filled and placeholders for the rest. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiWithRest = partialRight(format, 'Hi', partialRight.placeholder, partialRight.placeholder, partialRight.placeholder); + * hiWithRest('Fred', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, plc4: __): (t2: T2, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled and placeholders for the rest. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredWithRest = partialRight(format, 'Fred', partialRight.placeholder, partialRight.placeholder); + * greetFredWithRest('Hi', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, plc3: __, plc4: __): (t1: T1, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first two arguments pre-filled and placeholders for the rest. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredWithRest = partialRight(format, 'Hi', 'Fred', partialRight.placeholder, partialRight.placeholder); + * hiToFredWithRest('morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, plc4: __): (t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the third argument pre-filled and a placeholder for the fourth. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t2: T2, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const atMorningWithPunc = partialRight(format, 'morning', partialRight.placeholder); + * atMorningWithPunc('Hi', 'Fred', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg3: T3, plc4: __): (t1: T1, t2: T2, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first and third arguments pre-filled and a placeholder for the fourth. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t2: T2, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiAtMorningWithNameAndPunc = partialRight(format, 'Hi', partialRight.placeholder, 'morning', partialRight.placeholder); + * hiAtMorningWithNameAndPunc('Fred', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, plc4: __): (t2: T2, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the second and third arguments pre-filled and a placeholder for the fourth. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredAtMorningWithPunc = partialRight(format, 'Fred', 'morning', partialRight.placeholder); + * greetFredAtMorningWithPunc('Hi', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, arg3: T3, plc4: __): (t1: T1, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first three arguments pre-filled and a placeholder for the fourth. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredAtMorningWithPunc = partialRight(format, 'Hi', 'Fred', 'morning', partialRight.placeholder); + * hiToFredAtMorningWithPunc('!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, arg3: T3, plc4: __): (t4: T4) => R; +/** + * Creates a function that invokes the provided function with the fourth argument pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const withExclamation = partialRight(format, '!'); + * withExclamation('Hi', 'Fred', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg4: T4): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first and fourth arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiWithExclamation = partialRight(format, 'Hi', partialRight.placeholder, partialRight.placeholder, '!'); + * hiWithExclamation('Fred', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, arg4: T4): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the second and fourth arguments pre-filled and a placeholder for the third. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredWithTime = partialRight(format, 'Fred', partialRight.placeholder, '!'); + * greetFredWithTime('Hi', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, plc3: __, arg4: T4): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first, second and fourth arguments pre-filled and a placeholder for the third. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredWithTime = partialRight(format, 'Hi', 'Fred', partialRight.placeholder, '!'); + * hiToFredWithTime('morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, arg4: T4): (t3: T3) => R; +/** + * Creates a function that invokes the provided function with the third and fourth arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const inMorningWithExclamation = partialRight(format, 'morning', '!'); + * inMorningWithExclamation('Hi', 'Fred'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg3: T3, arg4: T4): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with the first, third and fourth arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiInMorningWithExclamation = partialRight(format, 'Hi', partialRight.placeholder, 'morning', '!'); + * hiInMorningWithExclamation('Fred'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, arg4: T4): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second, third and fourth arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredInMorningWithExclamation = partialRight(format, 'Fred', 'morning', '!'); + * greetFredInMorningWithExclamation('Hi'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with all arguments pre-filled. + * + * @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 {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const sayHiToFredInMorningWithExclamation = partialRight(format, 'Hi', 'Fred', 'morning', '!'); + * sayHiToFredInMorningWithExclamation(); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R; +/** + * Creates a function that invokes the provided function with partially applied arguments appended to the arguments it receives. + * The partialRight.placeholder value can be used as a placeholder for partially applied arguments. + * + * @template F The type of the function to partially apply + * @param {F} func The function to partially apply arguments to + * @param {...any[]} args The arguments to be partially applied + * @returns {(...args: any[]) => ReturnType} Returns the new partially applied function + * + * @example + * function greet(greeting: string, name: string) { + * return greeting + ' ' + name; + * } + * + * const greetFred = partialRight(greet, 'Fred'); + * greetFred('Hi'); // => 'Hi Fred' + * + * // Using placeholders + * const sayHelloTo = partialRight(greet, 'Hello', partialRight.placeholder); + * sayHelloTo('Fred'); // => 'Hello Fred' + */ +declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; +declare namespace partialRight { + var placeholder: Placeholder; +} +type Placeholder = symbol | (((value: any) => any) & { + partialRight: typeof partialRight; +}); + +export { partialRight }; Index: node_modules/es-toolkit/dist/compat/function/partialRight.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/partialRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/partialRight.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const partialRight$1 = require('../../function/partialRight.js'); + +function partialRight(func, ...partialArgs) { + return partialRight$1.partialRightImpl(func, partialRight.placeholder, ...partialArgs); +} +partialRight.placeholder = Symbol('compat.partialRight.placeholder'); + +exports.partialRight = partialRight; Index: node_modules/es-toolkit/dist/compat/function/partialRight.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/partialRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/partialRight.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,8 @@ +import { partialRightImpl } from '../../function/partialRight.mjs'; + +function partialRight(func, ...partialArgs) { + return partialRightImpl(func, partialRight.placeholder, ...partialArgs); +} +partialRight.placeholder = Symbol('compat.partialRight.placeholder'); + +export { partialRight }; Index: node_modules/es-toolkit/dist/compat/function/rearg.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/rearg.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/rearg.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,19 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Creates a function that invokes `func` with arguments arranged according to the specified `indices` + * where the argument value at the first index is provided as the first argument, + * the argument value at the second index is provided as the second argument, and so on. + * + * @param {(...args: any[]) => any} func The function to rearrange arguments for. + * @param {Array} indices The arranged argument indices. + * @returns {(...args: any[]) => any} Returns the new function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const rearrangedGreet = rearg(greet, 1, 0); + * console.log(rearrangedGreet('World', 'Hello')); // Output: "Hello, World!" + */ +declare function rearg(func: (...args: any[]) => any, ...indices: Array>): (...args: any[]) => any; + +export { rearg }; Index: node_modules/es-toolkit/dist/compat/function/rearg.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/rearg.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/rearg.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,19 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Creates a function that invokes `func` with arguments arranged according to the specified `indices` + * where the argument value at the first index is provided as the first argument, + * the argument value at the second index is provided as the second argument, and so on. + * + * @param {(...args: any[]) => any} func The function to rearrange arguments for. + * @param {Array} indices The arranged argument indices. + * @returns {(...args: any[]) => any} Returns the new function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const rearrangedGreet = rearg(greet, 1, 0); + * console.log(rearrangedGreet('World', 'Hello')); // Output: "Hello, World!" + */ +declare function rearg(func: (...args: any[]) => any, ...indices: Array>): (...args: any[]) => any; + +export { rearg }; Index: node_modules/es-toolkit/dist/compat/function/rearg.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/rearg.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/rearg.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('../array/flatten.js'); + +function rearg(func, ...indices) { + const flattenIndices = flatten.flatten(indices); + return function (...args) { + const reorderedArgs = flattenIndices.map(i => args[i]).slice(0, args.length); + for (let i = reorderedArgs.length; i < args.length; i++) { + reorderedArgs.push(args[i]); + } + return func.apply(this, reorderedArgs); + }; +} + +exports.rearg = rearg; Index: node_modules/es-toolkit/dist/compat/function/rearg.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/rearg.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/rearg.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,14 @@ +import { flatten } from '../array/flatten.mjs'; + +function rearg(func, ...indices) { + const flattenIndices = flatten(indices); + return function (...args) { + const reorderedArgs = flattenIndices.map(i => args[i]).slice(0, args.length); + for (let i = reorderedArgs.length; i < args.length; i++) { + reorderedArgs.push(args[i]); + } + return func.apply(this, reorderedArgs); + }; +} + +export { rearg }; Index: node_modules/es-toolkit/dist/compat/function/rest.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/rest.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/rest.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,32 @@ +/** + * 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. + * + * @param {(...args: any[]) => any} func - The function whose arguments are to be transformed. + * @param {number} [start=func.length - 1] - The index from which to start grouping the remaining arguments into an array. + * Defaults to `func.length - 1`, grouping all arguments after the last parameter. + * @returns {(...args: any[]) => any} A new function that, when called, returns the result of calling `func` with the transformed arguments. + * + * 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(func: (...args: any[]) => any, start?: number): (...args: any[]) => any; + +export { rest }; Index: node_modules/es-toolkit/dist/compat/function/rest.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/rest.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/rest.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,32 @@ +/** + * 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. + * + * @param {(...args: any[]) => any} func - The function whose arguments are to be transformed. + * @param {number} [start=func.length - 1] - The index from which to start grouping the remaining arguments into an array. + * Defaults to `func.length - 1`, grouping all arguments after the last parameter. + * @returns {(...args: any[]) => any} A new function that, when called, returns the result of calling `func` with the transformed arguments. + * + * 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(func: (...args: any[]) => any, start?: number): (...args: any[]) => any; + +export { rest }; Index: node_modules/es-toolkit/dist/compat/function/rest.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/rest.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/rest.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const rest$1 = require('../../function/rest.js'); + +function rest(func, start = func.length - 1) { + start = Number.parseInt(start, 10); + if (Number.isNaN(start) || start < 0) { + start = func.length - 1; + } + return rest$1.rest(func, start); +} + +exports.rest = rest; Index: node_modules/es-toolkit/dist/compat/function/rest.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/rest.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/rest.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +import { rest as rest$1 } from '../../function/rest.mjs'; + +function rest(func, start = func.length - 1) { + start = Number.parseInt(start, 10); + if (Number.isNaN(start) || start < 0) { + start = func.length - 1; + } + return rest$1(func, start); +} + +export { rest }; Index: node_modules/es-toolkit/dist/compat/function/spread.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/spread.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/spread.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,47 @@ +/** + * Creates a new function that spreads elements of an array argument into individual arguments + * for the original function. The array argument is positioned based on the `argsIndex` parameter. + * + * @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. + * @param {number} [argsIndex=0] - The index where the array argument is positioned among the other arguments. + * If `argsIndex` is negative or `NaN`, it defaults to `0`. If it's a fractional number, it is rounded to the nearest integer. + * @returns {(...args: any[]) => ReturnType} - A new function that takes multiple arguments, including an array of arguments at the specified `argsIndex`, + * 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 + * + * @example + * // Example function to spread arguments over + * function add(a, b) { + * return a + b; + * } + * + * // Create a new function that uses `spread` to combine arguments + * const spreadAdd = spread(add, 1); + * + * // Calling `spreadAdd` with an array as the second argument + * console.log(spreadAdd(1, [2])); // Output: 3 + * + * @example + * // Function with default arguments + * function greet(name, greeting = 'Hello') { + * return `${greeting}, ${name}!`; + * } + * + * // Create a new function that uses `spread` to position the argument array at index 0 + * const spreadGreet = spread(greet, 0); + * + * // Calling `spreadGreet` with an array of arguments + * console.log(spreadGreet(['Alice'])); // Output: Hello, Alice! + * console.log(spreadGreet(['Bob', 'Hi'])); // Output: Hi, Bob! + */ +declare function spread(func: (...args: any[]) => R, argsIndex?: number): (...args: any[]) => R; + +export { spread }; Index: node_modules/es-toolkit/dist/compat/function/spread.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/spread.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/spread.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,47 @@ +/** + * Creates a new function that spreads elements of an array argument into individual arguments + * for the original function. The array argument is positioned based on the `argsIndex` parameter. + * + * @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. + * @param {number} [argsIndex=0] - The index where the array argument is positioned among the other arguments. + * If `argsIndex` is negative or `NaN`, it defaults to `0`. If it's a fractional number, it is rounded to the nearest integer. + * @returns {(...args: any[]) => ReturnType} - A new function that takes multiple arguments, including an array of arguments at the specified `argsIndex`, + * 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 + * + * @example + * // Example function to spread arguments over + * function add(a, b) { + * return a + b; + * } + * + * // Create a new function that uses `spread` to combine arguments + * const spreadAdd = spread(add, 1); + * + * // Calling `spreadAdd` with an array as the second argument + * console.log(spreadAdd(1, [2])); // Output: 3 + * + * @example + * // Function with default arguments + * function greet(name, greeting = 'Hello') { + * return `${greeting}, ${name}!`; + * } + * + * // Create a new function that uses `spread` to position the argument array at index 0 + * const spreadGreet = spread(greet, 0); + * + * // Calling `spreadGreet` with an array of arguments + * console.log(spreadGreet(['Alice'])); // Output: Hello, Alice! + * console.log(spreadGreet(['Bob', 'Hi'])); // Output: Hi, Bob! + */ +declare function spread(func: (...args: any[]) => R, argsIndex?: number): (...args: any[]) => R; + +export { spread }; Index: node_modules/es-toolkit/dist/compat/function/spread.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/spread.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/spread.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function spread(func, argsIndex = 0) { + argsIndex = Number.parseInt(argsIndex, 10); + if (Number.isNaN(argsIndex) || argsIndex < 0) { + argsIndex = 0; + } + return function (...args) { + const array = args[argsIndex]; + const params = args.slice(0, argsIndex); + if (array) { + params.push(...array); + } + return func.apply(this, params); + }; +} + +exports.spread = spread; Index: node_modules/es-toolkit/dist/compat/function/spread.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/spread.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/spread.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,16 @@ +function spread(func, argsIndex = 0) { + argsIndex = Number.parseInt(argsIndex, 10); + if (Number.isNaN(argsIndex) || argsIndex < 0) { + argsIndex = 0; + } + return function (...args) { + const array = args[argsIndex]; + const params = args.slice(0, argsIndex); + if (array) { + params.push(...array); + } + return func.apply(this, params); + }; +} + +export { spread }; Index: node_modules/es-toolkit/dist/compat/function/throttle.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/throttle.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/throttle.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,81 @@ +import { DebouncedFuncLeading, DebouncedFunc } from './debounce.mjs'; + +interface ThrottleSettings { + /** + * If `true`, the function will be invoked on the leading edge of the timeout. + * @default true + */ + leading?: boolean | undefined; + /** + * If `true`, the function will be invoked on the trailing edge of the timeout. + * @default true + */ + trailing?: boolean | undefined; +} +type ThrottleSettingsLeading = (ThrottleSettings & { + leading: true; +}) | Omit; +/** + * 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. + * @param {ThrottleOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @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 any>(func: T, throttleMs?: number, options?: ThrottleSettingsLeading): DebouncedFuncLeading; +/** + * 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. + * @param {ThrottleOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @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 any>(func: T, throttleMs?: number, options?: ThrottleSettings): DebouncedFunc; + +export { throttle }; Index: node_modules/es-toolkit/dist/compat/function/throttle.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/throttle.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/throttle.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,81 @@ +import { DebouncedFuncLeading, DebouncedFunc } from './debounce.js'; + +interface ThrottleSettings { + /** + * If `true`, the function will be invoked on the leading edge of the timeout. + * @default true + */ + leading?: boolean | undefined; + /** + * If `true`, the function will be invoked on the trailing edge of the timeout. + * @default true + */ + trailing?: boolean | undefined; +} +type ThrottleSettingsLeading = (ThrottleSettings & { + leading: true; +}) | Omit; +/** + * 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. + * @param {ThrottleOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @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 any>(func: T, throttleMs?: number, options?: ThrottleSettingsLeading): DebouncedFuncLeading; +/** + * 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. + * @param {ThrottleOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @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 any>(func: T, throttleMs?: number, options?: ThrottleSettings): DebouncedFunc; + +export { throttle }; Index: node_modules/es-toolkit/dist/compat/function/throttle.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/throttle.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/throttle.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const debounce = require('./debounce.js'); + +function throttle(func, throttleMs = 0, options = {}) { + const { leading = true, trailing = true } = options; + return debounce.debounce(func, throttleMs, { + leading, + maxWait: throttleMs, + trailing, + }); +} + +exports.throttle = throttle; Index: node_modules/es-toolkit/dist/compat/function/throttle.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/throttle.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/throttle.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,12 @@ +import { debounce } from './debounce.mjs'; + +function throttle(func, throttleMs = 0, options = {}) { + const { leading = true, trailing = true } = options; + return debounce(func, throttleMs, { + leading, + maxWait: throttleMs, + trailing, + }); +} + +export { throttle }; Index: node_modules/es-toolkit/dist/compat/function/unary.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/unary.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/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(func: (arg1: T, ...args: any[]) => U): (arg1: T) => U; + +export { unary }; Index: node_modules/es-toolkit/dist/compat/function/unary.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/unary.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/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(func: (arg1: T, ...args: any[]) => U): (arg1: T) => U; + +export { unary }; Index: node_modules/es-toolkit/dist/compat/function/unary.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/unary.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/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/compat/function/unary.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/unary.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/unary.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,7 @@ +import { ary } from './ary.mjs'; + +function unary(func) { + return ary(func, 1); +} + +export { unary }; Index: node_modules/es-toolkit/dist/compat/function/wrap.d.mts =================================================================== --- node_modules/es-toolkit/dist/compat/function/wrap.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/wrap.d.mts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,27 @@ +/** + * Creates a new function that wraps the given function `func`. + * In this process, you can apply additional logic defined in the `wrapper` function before and after the execution of the original function. + * + * If a `value` is provided instead of a function, this value is passed as the first argument to the `wrapper` function. + * + * @template T - The type of the value being wrapped. + * @template U - The type of the arguments being passed to the `wrapper` function. + * @template V - The type of the return value of the `wrapper` function. + * @param {T} value - The value to be wrapped. + * @param {(value: T, ...args: U[]) => V} wrapper - The function to wrap the value with. + * @returns {(...args: U[]) => V} A new function that wraps the value with the `wrapper` function. + * + * @example + * // Wrap a function + * const greet = (name: string) => `Hi, ${name}`; + * const wrapped = wrap(greet, (value, name) => `[LOG] ${value(name)}`); + * wrapped('Bob'); // => "[LOG] Hi, Bob" + * + * @example + * // Wrap a primitive value + * const wrapped = wrap('value', v => `

${v}

`); + * wrapped(); // => "

value

" + */ +declare function wrap(value: T, wrapper: (value: T, ...args: U[]) => V): (...args: U[]) => V; + +export { wrap }; Index: node_modules/es-toolkit/dist/compat/function/wrap.d.ts =================================================================== --- node_modules/es-toolkit/dist/compat/function/wrap.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/wrap.d.ts (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,27 @@ +/** + * Creates a new function that wraps the given function `func`. + * In this process, you can apply additional logic defined in the `wrapper` function before and after the execution of the original function. + * + * If a `value` is provided instead of a function, this value is passed as the first argument to the `wrapper` function. + * + * @template T - The type of the value being wrapped. + * @template U - The type of the arguments being passed to the `wrapper` function. + * @template V - The type of the return value of the `wrapper` function. + * @param {T} value - The value to be wrapped. + * @param {(value: T, ...args: U[]) => V} wrapper - The function to wrap the value with. + * @returns {(...args: U[]) => V} A new function that wraps the value with the `wrapper` function. + * + * @example + * // Wrap a function + * const greet = (name: string) => `Hi, ${name}`; + * const wrapped = wrap(greet, (value, name) => `[LOG] ${value(name)}`); + * wrapped('Bob'); // => "[LOG] Hi, Bob" + * + * @example + * // Wrap a primitive value + * const wrapped = wrap('value', v => `

${v}

`); + * wrapped(); // => "

value

" + */ +declare function wrap(value: T, wrapper: (value: T, ...args: U[]) => V): (...args: U[]) => V; + +export { wrap }; Index: node_modules/es-toolkit/dist/compat/function/wrap.js =================================================================== --- node_modules/es-toolkit/dist/compat/function/wrap.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/wrap.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const isFunction = require('../../predicate/isFunction.js'); + +function wrap(value, wrapper) { + return function (...args) { + const wrapFn = isFunction.isFunction(wrapper) ? wrapper : identity.identity; + return wrapFn.apply(this, [value, ...args]); + }; +} + +exports.wrap = wrap; Index: node_modules/es-toolkit/dist/compat/function/wrap.mjs =================================================================== --- node_modules/es-toolkit/dist/compat/function/wrap.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/es-toolkit/dist/compat/function/wrap.mjs (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,11 @@ +import { identity } from '../../function/identity.mjs'; +import { isFunction } from '../../predicate/isFunction.mjs'; + +function wrap(value, wrapper) { + return function (...args) { + const wrapFn = isFunction(wrapper) ? wrapper : identity; + return wrapFn.apply(this, [value, ...args]); + }; +} + +export { wrap };