@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/compat/predicate/isSymbol.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Check whether a value is a symbol.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ * isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * isSymbol('abc');
+ * // => false
+ */
+export declare function isSymbol(value?: unknown): value is symbol;
+//# sourceMappingURL=isSymbol.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isSymbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSymbol.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isSymbol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEzD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/eq.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
+ *
+ * @param {unknown} value - The value to compare.
+ * @param {unknown} other - The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ *
+ * @example
+ * eq(1, 1); // true
+ * eq(0, -0); // true
+ * eq(NaN, NaN); // true
+ * eq('a', Object('a')); // false
+ */
+export declare function eq(value?: unknown, other?: unknown): boolean;
+//# sourceMappingURL=eq.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/eq.d.ts.map

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toFinite.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts `value` to a finite number.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {number} Returns the number.
+ *
+ * @example
+ * toNumber(3.2); // => 3.2
+ * toNumber(Number.MIN_VALUE); // => 5e-324
+ * toNumber(Infinity); // => 1.7976931348623157e+308
+ * toNumber('3.2'); // => 3.2
+ * toNumber(Symbol.iterator); // => 0
+ * toNumber(NaN); // => 0
+ */
+export declare function toFinite(value?: unknown): number;
+//# sourceMappingURL=toFinite.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toFinite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toFinite.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toFinite.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAahD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toInteger.d.ts

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toInteger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toInteger.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toInteger.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAKjD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toNumber.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Converts `value` to a number.
+ *
+ * Unlike `Number()`, this function returns `NaN` for symbols.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {number} Returns the number.
+ *
+ * @example
+ * toNumber(3.2); // => 3.2
+ * toNumber(Number.MIN_VALUE); // => 5e-324
+ * toNumber(Infinity); // => Infinity
+ * toNumber('3.2'); // => 3.2
+ * toNumber(Symbol.iterator); // => NaN
+ * toNumber(NaN); // => NaN
+ */
+export declare function toNumber(value?: unknown): number;
+//# sourceMappingURL=toNumber.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toNumber.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/util/toNumber.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAMhD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/error/AbortError.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An error class representing an aborted operation.
+ * @augments Error
+ */
+export declare class AbortError extends Error {
+    constructor(message?: string);
+}
+//# sourceMappingURL=AbortError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AbortError.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/error/AbortError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,UAAW,SAAQ,KAAK;gBACvB,OAAO,SAA8B;CAIlD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/error/TimeoutError.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An error class representing an timeout operation.
+ * @augments Error
+ */
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+//# sourceMappingURL=TimeoutError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TimeoutError.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/error/TimeoutError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,SAAgC;CAIpD"}

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

@@ -0,0 +1,3 @@
+export { AbortError } from './AbortError.js';
+export { TimeoutError } from './TimeoutError.js';
+//# sourceMappingURL=index.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/error/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/error/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"after.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/after.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,KAAK,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACrD,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,CAAC,GACN,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAYvD"}

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

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

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * An asynchronous no-operation function that does nothing.
+ * This can be used as a placeholder or default function.
+ *
+ * @example
+ * asyncNoop(); // Does nothing
+ *
+ * @returns {Promise<void>} This function returns a Promise that resolves to undefined.
+ */
+export declare function asyncNoop(): Promise<void>;
+//# sourceMappingURL=asyncNoop.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"before.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/before.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACtD,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,CAAC,GACN,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAcvD"}

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

@@ -0,0 +1,125 @@
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *   return 42;
+ * }
+ * const curriedNoArgFunc = curry(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+export declare function curry<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curry(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+export declare function curry<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *   return a + b;
+ * }
+ * const curriedTwoArgFunc = curry(twoArgFunc);
+ * const add5 = curriedTwoArgFunc(5);
+ * console.log(add5(10)); // 15
+ */
+export declare function curry<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => R} A curried function.
+ *
+ * @example
+ * function threeArgFunc(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ * const curriedThreeArgFunc = curry(threeArgFunc);
+ * const add1 = curriedThreeArgFunc(1);
+ * const add3 = add1(2);
+ * console.log(add3(3)); // 6
+ */
+export declare function curry<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *   return a + b + c + d;
+ * }
+ * const curriedFourArgFunc = curry(fourArgFunc);
+ * const add1 = curriedFourArgFunc(1);
+ * const add3 = add1(2);
+ * const add6 = add3(3);
+ * console.log(add6(4)); // 10
+ */
+export declare function curry<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return a + b + c + d + e;
+ * }
+ * const curriedFiveArgFunc = curry(fiveArgFunc);
+ * const add1 = curriedFiveArgFunc(1);
+ * const add3 = add1(2);
+ * const add6 = add3(3);
+ * const add10 = add6(4);
+ * console.log(add10(5)); // 15
+ */
+export declare function curry<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curry(sum);
+ *
+ * // The parameter `a` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5);
+ */
+export declare function curry(func: (...args: any[]) => any): (...args: any[]) => any;
+//# sourceMappingURL=curry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curry.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/curry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;AAEjD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AAE5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AAEzF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AAEjH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EACrC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAC1C,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EACzC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAClD,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC"}

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

@@ -0,0 +1,139 @@
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *  return 42;
+ * }
+ * const curriedNoArgFunc = curryRight(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+export declare function curryRight<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curryRight(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+export declare function curryRight<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *  return [a, b];
+ * }
+ * const curriedTwoArgFunc = curryRight(twoArgFunc);
+ * const func = curriedTwoArgFunc(1);
+ * console.log(func(2)); // [2, 1]
+ */
+export declare function curryRight<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry.
+ * @returns {(p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function threeArgFunc(a: number, b: number, c: number) {
+ *   return [a, b, c];
+ * }
+ * const curriedThreeArgFunc = curryRight(threeArgFunc);
+ * const func = curriedThreeArgFunc(1);
+ * const func2 = func(2);
+ * console.log(func2(3)); // [3, 2, 1]
+ */
+export declare function curryRight<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *  return [a, b, c, d];
+ * }
+ * const curriedFourArgFunc = curryRight(fourArgFunc);
+ * const func = curriedFourArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * console.log(func3(4)); // [4, 3, 2, 1]
+ */
+export declare function curryRight<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return [a, b, c, d, e];
+ * }
+ * const curriedFiveArgFunc = curryRight(fiveArgFunc);
+ * const func = curriedFiveArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * const func4 = func3(4);
+ * console.log(func4(5)); // [5, 4, 3, 2, 1]
+ */
+export declare function curryRight<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curryRight(sum);
+ *
+ * // The parameter `c` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5); // 30
+ */
+export declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any;
+//# sourceMappingURL=curryRight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curryRight.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/curryRight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;AACtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AACjE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AAC9F;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AACtH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAC1C,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAC1C,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AACrD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAC9C,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAClD,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AACjE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC"}

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

@@ -0,0 +1,74 @@
+interface DebounceOptions {
+    /**
+     * An optional AbortSignal to cancel the debounced function.
+     */
+    signal?: AbortSignal;
+    /**
+     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
+     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
+     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
+     * @default ["trailing"]
+     */
+    edges?: Array<'leading' | 'trailing'>;
+}
+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

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