@fedify/fedify 1.6.0-dev.808 → 1.6.0-dev.810

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

@@ -0,0 +1,131 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,143 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,21 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,123 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,34 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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"}