@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/rest.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+export declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;
+//# sourceMappingURL=rest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/rest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACpD,IAAI,EAAE,CAAC,EACP,UAAU,SAAkB,GAC3B,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,UAAU,CAAC,CAAC,CAAC,CASnC"}

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

@@ -0,0 +1,77 @@
+interface RetryOptions {
+    /**
+     * Delay between retries. Can be a static number (milliseconds) or a function
+     * that computes delay dynamically based on the current attempt.
+     *
+     * @default 0
+     * @example
+     * delay: (attempts) => attempt * 50
+     */
+    delay?: number | ((attempts: number) => number);
+    /**
+     * The number of retries to attempt.
+     * @default Number.POSITIVE_INFINITY
+     */
+    retries?: number;
+    /**
+     * An AbortSignal to cancel the retry operation.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Retries a function that returns a promise until it resolves successfully.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Basic usage with default retry options
+ * retry(() => fetchData()).then(data => console.log(data));
+ */
+export declare function retry<T>(func: () => Promise<T>): Promise<T>;
+/**
+ * Retries a function that returns a promise a specified number of times.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {number} retries - The number of retries to attempt. Default is Infinity.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function up to 3 times
+ * retry(() => fetchData(), 3).then(data => console.log(data));
+ */
+export declare function retry<T>(func: () => Promise<T>, retries: number): Promise<T>;
+/**
+ * Retries a function that returns a promise with specified options.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {RetryOptions} options - Options to configure the retry behavior.
+ * @param {number | ((attempts: number) => number)} [options.delay=0] - Delay(milliseconds) between retries.
+ * @param {number} [options.retries=Infinity] - The number of retries to attempt.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function with a delay of 1000ms between attempts
+ * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data));
+ *
+ * @example
+ * // Retry a function with a fixed delay
+ * retry(() => fetchData(), { delay: 1000, retries: 5 });
+ *
+ * // Retry a function with a delay increasing linearly by 50ms per attempt
+ * retry(() => fetchData(), { delay: (attempts) => attempt * 50, retries: 5 });
+ *
+ * @example
+ * // Retry a function with exponential backoff + jitter (max delay 10 seconds)
+ * retry(() => fetchData(), {
+ *   delay: (attempts) => Math.min(Math.random() * 100 * 2 ** attempts, 10000),
+ *   retries: 5
+ * });
+ */
+export declare function retry<T>(func: () => Promise<T>, options: RetryOptions): Promise<T>;
+export {};
+//# sourceMappingURL=retry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/retry.ts"],"names":[],"mappings":"AAEA,UAAU,YAAY;IACpB;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAEhD;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAKD;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,18 @@
+/**
+ * Creates a new function that spreads elements of an array argument into individual arguments
+ * for the original function.
+ *
+ * @template F - A function type with any number of parameters and any return type.
+ * @param {F} func - The function to be transformed. It can be any function with any number of arguments.
+ * @returns {(argsArr: Parameters<F>) => ReturnType<F>} - A new function that takes an array of arguments and returns the result of calling the original function with those arguments.
+ *
+ * @example
+ * function add(a, b) {
+ *   return a + b;
+ * }
+ *
+ * const spreadAdd = spread(add);
+ * console.log(spreadAdd([1, 2])); // Output: 3
+ */
+export declare function spread<F extends (...args: any[]) => any>(func: F): (argsArr: Parameters<F>) => ReturnType<F>;
+//# sourceMappingURL=spread.d.ts.map

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

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

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

@@ -0,0 +1,48 @@
+interface ThrottleOptions {
+    /**
+     * 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 ["leading", "trailing"]
+     */
+    edges?: Array<'leading' | 'trailing'>;
+}
+export interface ThrottledFunction<F extends (...args: any[]) => void> {
+    (...args: Parameters<F>): void;
+    cancel: () => void;
+    flush: () => void;
+}
+/**
+ * Creates a throttled function that only invokes the provided function at most once
+ * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ *
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ *
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+export declare function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction<F>;
+export {};
+//# sourceMappingURL=throttle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/throttle.ts"],"names":[],"mappings":"AAEA,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;IAC/B,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;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,KAA+B,EAAE,GAAE,eAAoB,GAChE,iBAAiB,CAAC,CAAC,CAAC,CAsBtB"}

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

@@ -0,0 +1,16 @@
+/**
+ * Creates a function that accepts up to one argument, ignoring any additional arguments.
+ *
+ * @template F - The type of the function.
+ * @param {F} func - The function to cap arguments for.
+ * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
+ *
+ * @example
+ * function fn(a, b, c) {
+ *   console.log(arguments);
+ * }
+ *
+ * unary(fn)(1, 2, 3); // [Arguments] { '0': 1 }
+ */
+export declare function unary<F extends (...args: any[]) => any>(func: F): (...args: any[]) => ReturnType<F>;
+//# sourceMappingURL=unary.d.ts.map

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

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

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

@@ -0,0 +1,66 @@
+/**
+ * es-toolkit
+ * ====================================
+ * A modern JavaScript utility library that's 2-3 times faster and up to 97% smaller—a major upgrade to lodash.
+ *
+ * es-toolkit is a state-of-the-art, high-performance JavaScript utility library
+ * with a small bundle size and strong type annotations.
+ *
+ * - es-toolkit offers a variety of everyday utility functions with modern implementations, such as [debounce](https://es-toolkit.slash.page/reference/function/debounce.html), [delay](https://es-toolkit.slash.page/reference/promise/delay.html), [chunk](https://es-toolkit.slash.page/reference/array/chunk.html), [sum](https://es-toolkit.slash.page/reference/math/sum.html), and [pick](https://es-toolkit.slash.page/reference/object/pick.html).
+ * - Designed with performance in mind, es-toolkit achieves [2-3× better performance](https://es-toolkit.slash.page/performance.html) in modern JavaScript environments.
+ * - es-toolkit supports tree shaking out of the box, and [reduces JavaScript code by up to 97%](https://es-toolkit.slash.page/bundle-size.html) compared to other libraries.
+ * - es-toolkit includes built-in TypeScript support, with straightforward yet robust types. It also provides useful type guards such as [isNotNil](https://es-toolkit.slash.page/reference/predicate/isNotNil.html).
+ * - es-toolkit is battle-tested with 100% test coverage, ensuring reliability and robustness.
+ *
+ * ## Features
+ *
+ * Here are some of the features es-toolkit offers:
+ *
+ * - **Array**: Utilities for array manipulation, such as [uniq](https://es-toolkit.slash.page/reference/array/uniq.html) and [difference](https://es-toolkit.slash.page/reference/array/difference.html).
+ * - **Function**: Tools for controlling function execution, including [debounce](https://es-toolkit.slash.page/reference/function/debounce.html) and [throttle](https://es-toolkit.slash.page/reference/function/throttle.html).
+ * - **Math**: Numerical utilities like [sum](https://es-toolkit.slash.page/reference/math/sum.html) and [round](https://es-toolkit.slash.page/reference/math/round.html).
+ * - **Object**: Tools for manipulating JavaScript objects, such as [pick](https://es-toolkit.slash.page/reference/object/pick.html) and [omit](https://es-toolkit.slash.page/reference/object/omit.html).
+ * - **Predicate**: Type guard functions like [isNotNil](https://es-toolkit.slash.page/reference/predicate/isNotNil.html).
+ * - **Promise**: Asynchronous utilities like [delay](https://es-toolkit.slash.page/reference/promise/delay.html).
+ * - **String**: Utilities for string manipulation, such as [snakeCase](https://es-toolkit.slash.page/reference/string/snakeCase.html)
+ *
+ * ## Examples
+ *
+ * ```typescript
+ * // import from '@es-toolkit/es-toolkit' in jsr.
+ * import { debounce, chunk } from 'es-toolkit';
+ *
+ * const debouncedLog = debounce(message => {
+ *   console.log(message);
+ * }, 300);
+ *
+ * // This call will be debounced
+ * debouncedLog('Hello, world!');
+ *
+ * const array = [1, 2, 3, 4, 5, 6];
+ * const chunkedArray = chunk(array, 2);
+ *
+ * console.log(chunkedArray);
+ * // Output: [[1, 2], [3, 4], [5, 6]]
+ * ```
+ *
+ * ## Resources
+ *
+ * If you want to know more about the project, please take a look at the
+ * following resources:
+ *
+ * - [GitHub](https://github.com/toss/es-toolkit)
+ * - [Documentation](https://es-toolkit.slash.page)
+ *
+ * @module
+ */
+export * from './array/index.js';
+export * from './error/index.js';
+export * from './function/index.js';
+export * from './math/index.js';
+export * from './object/index.js';
+export * from './predicate/index.js';
+export * from './promise/index.js';
+export * from './string/index.js';
+export * from './util/index.js';
+//# sourceMappingURL=index.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/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/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/clamp.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Clamps a number within the inclusive upper bound.
+ *
+ * This function takes a number and a maximum bound, and returns the number clamped within the specified upper bound.
+ * If only one bound is provided, it returns the minimum of the value and the bound.
+ *
+ * @param {number} value - The number to clamp.
+ * @param {number} maximum - The maximum bound to clamp the number.
+ * @returns {number} The clamped number within the specified upper bound.
+ *
+ * @example
+ * const result1 = clamp(10, 5); // result1 will be 5, as 10 is clamped to the bound 5
+ */
+export declare function clamp(value: number, maximum: number): number;
+/**
+ * Clamps a number within the inclusive lower and upper bounds.
+ *
+ * This function takes a number and two bounds, and returns the number clamped within the specified bounds.
+ *
+ * @param {number} value - The number to clamp.
+ * @param {number} minimum - The minimum bound to clamp the number.
+ * @param {number} maximum - The maximum bound to clamp the number.
+ * @returns {number} The clamped number within the specified bounds.
+ *
+ * @example
+ * const result2 = clamp(10, 5, 15); // result2 will be 10, as it is within the bounds 5 and 15
+ * const result3 = clamp(2, 5, 15); // result3 will be 5, as 2 is clamped to the lower bound 5
+ * const result4 = clamp(20, 5, 15); // result4 will be 15, as 20 is clamped to the upper bound 15
+ */
+export declare function clamp(value: number, minimum: number, maximum: number): number;
+//# sourceMappingURL=clamp.d.ts.map

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

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/inRange.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Checks if the value is less than the maximum.
+ *
+ * @param {number} value The value to check.
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is less than the maximum, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 5); // result will be true.
+ * const result2 = inRange(5, 5); // result2 will be false.
+ */
+export declare function inRange(value: number, maximum: number): boolean;
+/**
+ * Checks if the value is within the range defined by minimum (inclusive) and maximum (exclusive).
+ *
+ * @param {number} value The value to check.
+ * @param {number} minimum The lower bound of the range (inclusive).
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is within the specified range, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 2, 5); // result will be true.
+ * const result2 = inRange(1, 2, 5); // result2 will be false.
+ */
+export declare function inRange(value: number, minimum: number, maximum: number): boolean;
+//# sourceMappingURL=inRange.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inRange.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/inRange.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC"}

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

@@ -0,0 +1,14 @@
+export { clamp } from './clamp.js';
+export { inRange } from './inRange.js';
+export { mean } from './mean.js';
+export { meanBy } from './meanBy.js';
+export { median } from './median.js';
+export { medianBy } from './medianBy.js';
+export { random } from './random.js';
+export { randomInt } from './randomInt.js';
+export { range } from './range.js';
+export { rangeRight } from './rangeRight.js';
+export { round } from './round.js';
+export { sum } from './sum.js';
+export { sumBy } from './sumBy.js';
+//# sourceMappingURL=index.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/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/math/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/mean.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Calculates the average of an array of numbers.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @param {number[]} nums - An array of numbers to calculate the average.
+ * @returns {number} The average of all the numbers in the array.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const result = mean(numbers);
+ * // result will be 3
+ */
+export declare function mean(nums: readonly number[]): number;
+//# sourceMappingURL=mean.d.ts.map

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

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/meanBy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Calculates the average of an array of numbers when applying
+ * the `getValue` function to each element.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the average.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {number} The average of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2
+ * meanBy([], x => x.a); // Returns: NaN
+ */
+export declare function meanBy<T>(items: readonly T[], getValue: (element: T) => number): number;
+//# sourceMappingURL=meanBy.d.ts.map

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

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/median.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Calculates the median of an array of numbers.
+ *
+ * The median is the middle value of a sorted array.
+ * If the array has an odd number of elements, the median is the middle value.
+ * If the array has an even number of elements, it returns the average of the two middle values.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @param {number[]} nums - An array of numbers to calculate the median.
+ * @returns {number} The median of all the numbers in the array.
+ *
+ * @example
+ * const arrayWithOddNumberOfElements = [1, 2, 3, 4, 5];
+ * const result = median(arrayWithOddNumberOfElements);
+ * // result will be 3
+ *
+ * @example
+ * const arrayWithEvenNumberOfElements = [1, 2, 3, 4];
+ * const result = median(arrayWithEvenNumberOfElements);
+ * // result will be 2.5
+ */
+export declare function median(nums: readonly number[]): number;
+//# sourceMappingURL=median.d.ts.map

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

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/medianBy.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Calculates the median of an array of elements when applying
+ * the `getValue` function to each element.
+ *
+ * The median is the middle value of a sorted array.
+ * If the array has an odd number of elements, the median is the middle value.
+ * If the array has an even number of elements, it returns the average of the two middle values.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the median.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {number} The median of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }], x => x.a); // Returns: 3
+ * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }], x => x.a); // Returns: 2.5
+ * medianBy([], x => x.a); // Returns: NaN
+ */
+export declare function medianBy<T>(items: readonly T[], getValue: (element: T) => number): number;
+//# sourceMappingURL=medianBy.d.ts.map

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

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/random.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Generate a random number within the given range.
+ *
+ * If only one argument is provided, a number between `0` and the given number is returned.
+ *
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random number between 0 (inclusive) and maximum (exclusive). The number can be an integer or a decimal.
+ * @throws {Error} Throws an error if `maximum` is not greater than `0`.
+ *
+ * @example
+ * const result1 = random(5); // Returns a random number between 0 and 5.
+ * const result2 = random(0); // If the `maximum` is less than or equal to 0, an error is thrown.
+ */
+export declare function random(maximum: number): number;
+/**
+ * Generate a random number within the given range.
+ *
+ * @param {number} minimum - The lower bound (inclusive).
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal.
+ * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.
+ *
+ * @example
+ * const result1 = random(0, 5); // Returns a random number between 0 and 5.
+ * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown.
+ * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown.
+ */
+export declare function random(minimum: number, maximum: number): number;
+//# sourceMappingURL=random.d.ts.map

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

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

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/randomInt.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Generates a random integer between 0 (inclusive) and the given maximum (exclusive).
+ *
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random integer between 0 (inclusive) and maximum (exclusive).
+ * @throws {Error} Throws an error if `maximum` is not greater than `0`.
+ *
+ * @example
+ * const result = randomInt(5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)
+ */
+export declare function randomInt(maximum: number): number;
+/**
+ * Generates a random integer between minimum (inclusive) and maximum (exclusive).
+ *
+ * @param {number} minimum - The lower bound (inclusive).
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive).
+ * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.
+ *
+ * @example
+ * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)
+ * const result2 = randomInt(5, 0); // This will throw an error
+ */
+export declare function randomInt(minimum: number, maximum: number): number;
+//# sourceMappingURL=randomInt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"randomInt.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/randomInt.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/range.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Returns an array of numbers from `0` (inclusive) to `end` (exclusive), incrementing by `1`.
+ *
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `0` (inclusive) to `end` (exclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [0, 1, 2, 3]
+ * range(4);
+ */
+export declare function range(end: number): number[];
+/**
+ * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `1`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [1, 2, 3]
+ * range(1, 4);
+ */
+export declare function range(start: number, end: number): number[];
+/**
+ * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `step`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @param {number} step - The step value for the range.
+ * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with the specified `step`.
+ *
+ * @example
+ * // Returns [0, 5, 10, 15]
+ * range(0, 20, 5);
+ */
+export declare function range(start: number, end: number, step: number): number[];
+//# sourceMappingURL=range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAE5D;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/rangeRight.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Returns an array of numbers from `end` (exclusive) to `0` (inclusive), decrementing by `1`.
+ *
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `0` (inclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [3, 2, 1, 0]
+ * rangeRight(4);
+ */
+export declare function rangeRight(end: number): number[];
+/**
+ * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `1`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [3, 2, 1]
+ * rangeRight(1, 4);
+ */
+export declare function rangeRight(start: number, end: number): number[];
+/**
+ * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `step`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @param {number} step - The step value for the range.
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with the specified `step`.
+ *
+ * @example
+ * // Returns [15, 10, 5, 0]
+ * rangeRight(0, 20, 5);
+ */
+export declare function rangeRight(start: number, end: number, step: number): number[];
+//# sourceMappingURL=rangeRight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rangeRight.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/rangeRight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC"}