@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/debounce.d.ts

@@ -1,74 +0,0 @@
-interface DebounceOptions {
-    /**
-     * An optional AbortSignal to cancel the debounced function.
-     */
-    signal?: AbortSignal;
-    /**
-     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
-     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
-     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
-     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
-     * @default ["trailing"]
-     */
-    edges?: Array<'leading' | 'trailing'>;
-}
-export interface DebouncedFunction<F extends (...args: any[]) => void> {
-    (...args: Parameters<F>): void;
-    /**
-     * Schedules the execution of the debounced function after the specified debounce delay.
-     * This method resets any existing timer, ensuring that the function is only invoked
-     * after the delay has elapsed since the last call to the debounced function.
-     * It is typically called internally whenever the debounced function is invoked.
-     *
-     * @returns {void}
-     */
-    schedule: () => void;
-    /**
-     * Cancels any pending execution of the debounced function.
-     * This method clears the active timer and resets any stored context or arguments.
-     */
-    cancel: () => void;
-    /**
-     * Immediately invokes the debounced function if there is a pending execution.
-     * This method also cancels the current timer, ensuring that the function executes right away.
-     */
-    flush: () => void;
-}
-/**
- * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
- * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
- * method to cancel any pending execution.
- *
- * @template F - The type of function.
- * @param {F} func - The function to debounce.
- * @param {number} debounceMs - The number of milliseconds to delay.
- * @param {DebounceOptions} options - The options object
- * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
- * @returns A new debounced function with a `cancel` method.
- *
- * @example
- * const debouncedFunction = debounce(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' after 1 second if not called again in that time
- * debouncedFunction();
- *
- * // Will not log anything as the previous call is canceled
- * debouncedFunction.cancel();
- *
- * // With AbortSignal
- * const controller = new AbortController();
- * const signal = controller.signal;
- * const debouncedWithSignal = debounce(() => {
- *  console.log('Function executed');
- * }, 1000, { signal });
- *
- * debouncedWithSignal();
- *
- * // Will cancel the debounced function call
- * controller.abort();
- */
-export declare function debounce<F extends (...args: any[]) => void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction<F>;
-export {};
-//# sourceMappingURL=debounce.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/debounce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/debounce.ts"],"names":[],"mappings":"AAAA,UAAU,eAAe;IACvB;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IAErB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,UAAU,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;IACnE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE/B;;;;;;;OAOG;IACH,QAAQ,EAAE,MAAM,IAAI,CAAC;IAErB;;;OAGG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;IAEnB;;;OAGG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EACzD,IAAI,EAAE,CAAC,EACP,UAAU,EAAE,MAAM,EAClB,EAAE,MAAM,EAAE,KAAK,EAAE,GAAE,eAAoB,GACtC,iBAAiB,CAAC,CAAC,CAAC,CAgFtB"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/flow.d.ts

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/flow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;AAC7C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;AACnF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AAC7G;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAC9C,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,EACtB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,GAChB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AACtB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAClD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,EACtB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,GAChB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AACtB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EACtD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,EACtB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,GAChB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AACtB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/flowRight.d.ts

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/flowRight.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flowRight.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/flowRight.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;AAClD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;AACxF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AAClH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EACnD,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,GACrB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AACtB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EACvD,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,GACrB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AACtB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAC3D,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EACjB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,GACrB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC;AACtB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/identity.d.ts

@@ -1,21 +0,0 @@
-/**
- * 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' });
- */
-export declare function identity<T>(x: T): T;
-//# sourceMappingURL=identity.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/identity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAEnC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/index.d.ts

@@ -1,22 +0,0 @@
-export { after } from './after.js';
-export { ary } from './ary.js';
-export { asyncNoop } from './asyncNoop.js';
-export { before } from './before.js';
-export { curry } from './curry.js';
-export { curryRight } from './curryRight.js';
-export { debounce, type DebouncedFunction } from './debounce.js';
-export { flow } from './flow.js';
-export { flowRight } from './flowRight.js';
-export { identity } from './identity.js';
-export { memoize, type MemoizeCache } from './memoize.js';
-export { negate } from './negate.js';
-export { noop } from './noop.js';
-export { once } from './once.js';
-export { partial } from './partial.js';
-export { partialRight } from './partialRight.js';
-export { rest } from './rest.js';
-export { retry } from './retry.js';
-export { spread } from './spread.js';
-export { throttle, type ThrottledFunction } from './throttle.js';
-export { unary } from './unary.js';
-//# sourceMappingURL=index.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/memoize.d.ts

@@ -1,123 +0,0 @@
-/**
- * Creates a memoized version of the provided function. The memoized function caches
- * results based on the argument it receives, so if the same argument is passed again,
- * it returns the cached result instead of recomputing it.
- *
- * This function works with functions that take zero or just one argument. If your function
- * originally takes multiple arguments, you should refactor it to take a single object or array
- * that combines those arguments.
- *
- * If the argument is not primitive (e.g., arrays or objects), provide a
- * `getCacheKey` function to generate a unique cache key for proper caching.
- *
- * @template F - The type of the function to be memoized.
- * @param {F} fn - The function to be memoized. It should accept a single argument and return a value.
- * @param {MemoizeOptions<Parameters<F>[0], ReturnType<F>>} [options={}] - Optional configuration for the memoization.
- * @param {MemoizeCache<any, V>} [options.cache] - The cache object used to store results. Defaults to a new `Map`.
- * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
- *
- * @returns The memoized function with an additional `cache` property that exposes the internal cache.
- *
- * @example
- * // Example using the default cache
- * const add = (x: number) => x + 10;
- * const memoizedAdd = memoize(add);
- *
- * console.log(memoizedAdd(5)); // 15
- * console.log(memoizedAdd(5)); // 15 (cached result)
- * console.log(memoizedAdd.cache.size); // 1
- *
- * @example
- * // Example using a custom resolver
- * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
- * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
- * console.log(memoizedSum([1, 2])); // 3
- * console.log(memoizedSum([1, 2])); // 3 (cached result)
- * console.log(memoizedSum.cache.size); // 1
- *
- * @example
- * // Example using a custom cache implementation
- * class CustomCache<K, T> implements MemoizeCache<K, T> {
- *   private cache = new Map<K, T>();
- *
- *   set(key: K, value: T): void {
- *     this.cache.set(key, value);
- *   }
- *
- *   get(key: K): T | undefined {
- *     return this.cache.get(key);
- *   }
- *
- *   has(key: K): boolean {
- *     return this.cache.has(key);
- *   }
- *
- *   delete(key: K): boolean {
- *     return this.cache.delete(key);
- *   }
- *
- *   clear(): void {
- *     this.cache.clear();
- *   }
- *
- *   get size(): number {
- *     return this.cache.size;
- *   }
- * }
- * const customCache = new CustomCache<string, number>();
- * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
- * console.log(memoizedSumWithCustomCache([1, 2])); // 3
- * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
- * console.log(memoizedAddWithCustomCache.cache.size); // 1
- */
-export declare function memoize<F extends (...args: any) => any>(fn: F, options?: {
-    cache?: MemoizeCache<any, ReturnType<F>>;
-    getCacheKey?: (args: Parameters<F>[0]) => unknown;
-}): F & {
-    cache: MemoizeCache<any, ReturnType<F>>;
-};
-/**
- * Represents a cache for memoization, allowing storage and retrieval of computed values.
- *
- * @template K - The type of keys used to store values in the cache.
- * @template V - The type of values stored in the cache.
- */
-export interface MemoizeCache<K, V> {
-    /**
-     * Stores a value in the cache with the specified key.
-     *
-     * @param key - The key to associate with the value.
-     * @param value - The value to store in the cache.
-     */
-    set(key: K, value: V): void;
-    /**
-     * Retrieves a value from the cache by its key.
-     *
-     * @param key - The key of the value to retrieve.
-     * @returns The value associated with the key, or undefined if the key does not exist.
-     */
-    get(key: K): V | undefined;
-    /**
-     * Checks if a value exists in the cache for the specified key.
-     *
-     * @param key - The key to check for existence in the cache.
-     * @returns True if the cache contains the key, false otherwise.
-     */
-    has(key: K): boolean;
-    /**
-     * Deletes a value from the cache by its key.
-     *
-     * @param key - The key of the value to delete.
-     * @returns True if the value was successfully deleted, false otherwise.
-     */
-    delete(key: K): boolean | void;
-    /**
-     * Clears all values from the cache.
-     */
-    clear(): void;
-    /**
-     * The number of entries in the cache.
-     */
-    size: number;
-}
-//# sourceMappingURL=memoize.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/memoize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/memoize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,EACrD,EAAE,EAAE,CAAC,EACL,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,YAAY,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IACzC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC;CAC9C,GACL,CAAC,GAAG;IAAE,KAAK,EAAE,YAAY,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;CAAE,CAoBjD;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,EAAE,CAAC;IAChC;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAE5B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE3B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAErB;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC;IAE/B;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACd"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/negate.d.ts

@@ -1,15 +0,0 @@
-/**
- * Creates a function that negates the result of the predicate function.
- *
- * @template F - The type of the function to negate.
- * @param {F} func - The function to negate.
- * @returns {F} The new negated function, which negates the boolean result of `func`.
- *
- * @example
- * const array = [1, 2, 3, 4, 5, 6];
- * const isEven = (n: number) => n % 2 === 0;
- * const result = array.filter(negate(isEven));
- * // result will be [1, 3, 5]
- */
-export declare function negate<F extends (...args: any[]) => boolean>(func: F): F;
-//# sourceMappingURL=negate.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/negate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"negate.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/negate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAExE"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/noop.d.ts

@@ -1,11 +0,0 @@
-/**
- * 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.
- */
-export declare function noop(): void;
-//# sourceMappingURL=noop.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/noop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"noop.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/noop.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,IAAI,IAAI,IAAI,CAAG"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/once.d.ts

@@ -1,34 +0,0 @@
-/**
- * Creates a function that is restricted to invoking the provided function `func` once.
- * Repeated calls to the function will return the value from the first invocation.
- *
- * @template F - The type of function.
- * @param {F extends () => any} func - The function to restrict.
- * @returns {F} A new function that invokes `func` once and caches the result.
- *
- * @example
- * const initialize = once(() => {
- *   console.log('Initialized!');
- *   return true;
- * });
- *
- * initialize(); // Logs: 'Initialized!' and returns true
- * initialize(); // Returns true without logging
- */
-export declare function once<F extends () => any>(func: F): F;
-/**
- * Creates a function that is restricted to invoking the provided function `func` once.
- * Repeated calls to the function will return the value from the first invocation.
- *
- * @template F - The type of function.
- * @param {F extends (...args: any[]) => void} func - The function to restrict with arguments.
- * @returns {F} A new function that invokes `func` once.
- *
- * @example
- * const log = once(console.log);
- *
- * log('Hello, world!'); // prints 'Hello, world!' and doesn't return anything
- * log('Hello, world!'); // doesn't print anything and doesn't return anything
- */
-export declare function once<F extends (...args: any[]) => void>(func: F): F;
-//# sourceMappingURL=once.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/once.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"once.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/once.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,GAAG,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;AACtD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC"}