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

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/identity.js

@@ -0,0 +1,22 @@
+/**
+ * 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 function identity(x) {
+    return x;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/index.js

@@ -0,0 +1,21 @@
+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 } from './debounce.js';
+export { flow } from './flow.js';
+export { flowRight } from './flowRight.js';
+export { identity } from './identity.js';
+export { memoize } 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 } from './throttle.js';
+export { unary } from './unary.js';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/memoize.js

@@ -0,0 +1,86 @@
+/**
+ * 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 function memoize(fn, options = {}) {
+    const { cache = new Map(), getCacheKey } = options;
+    const memoizedFn = function (arg) {
+        const key = getCacheKey ? getCacheKey(arg) : arg;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn.call(this, arg);
+        cache.set(key, result);
+        return result;
+    };
+    memoizedFn.cache = cache;
+    return memoizedFn;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/negate.js

@@ -0,0 +1,16 @@
+/**
+ * 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 function negate(func) {
+    return ((...args) => !func(...args));
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/noop.js

@@ -0,0 +1,10 @@
+/**
+ * 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 function noop() { }

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/once.js

@@ -0,0 +1,28 @@
+/**
+ * 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} func - The function to restrict.
+ * @returns {(...args: Parameters<F>) => ReturnType<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 function once(func) {
+    let called = false;
+    let cache;
+    return function (...args) {
+        if (!called) {
+            called = true;
+            cache = func(...args);
+        }
+        return cache;
+    };
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/partial.js

@@ -0,0 +1,45 @@
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of partially applied functions.
+ *
+ * @template F The type of the function to partially apply.
+ * @param {F} func The function to partially apply arguments to.
+ * @param {any[]} partialArgs The arguments to be partially applied.
+ * @returns {(...args: any[]) => ReturnType<F>} Returns the new partially applied function.
+ *
+ * @example
+ * function greet(greeting, name) {
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * const sayHelloTo = partial(greet, 'hello');
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ *
+ * // Partially applied with placeholders.
+ * const greetFred = partial(greet, partial.placeholder, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ */
+export function partial(func, ...partialArgs) {
+    return partialImpl(func, placeholderSymbol, ...partialArgs);
+}
+export function partialImpl(func, placeholder, ...partialArgs) {
+    const partialed = function (...providedArgs) {
+        let providedArgsIndex = 0;
+        const substitutedArgs = partialArgs
+            .slice()
+            .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg));
+        const remainingArgs = providedArgs.slice(providedArgsIndex);
+        return func.apply(this, substitutedArgs.concat(remainingArgs));
+    };
+    if (func.prototype) {
+        partialed.prototype = Object.create(func.prototype);
+    }
+    return partialed;
+}
+const placeholderSymbol = Symbol('partial.placeholder');
+partial.placeholder = placeholderSymbol;

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/partialRight.js

@@ -0,0 +1,47 @@
+/**
+ * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
+ *
+ * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of partially applied functions.
+ *
+ * @template F The type of the function to partially apply.
+ * @param {F} func The function to partially apply arguments to.
+ * @param {any[]} partialArgs The arguments to be partially applied.
+ * @returns {(...args: any[]) => ReturnType<F>} Returns the new partially applied function.
+ *
+ * @example
+ * function greet(greeting, name) {
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * const greetFred = partialRight(greet, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ *
+ * // Partially applied with placeholders.
+ * const sayHelloTo = partialRight(greet, 'hello', partialRight.placeholder);
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ */
+export function partialRight(func, ...partialArgs) {
+    return partialRightImpl(func, placeholderSymbol, ...partialArgs);
+}
+export function partialRightImpl(func, placeholder, ...partialArgs) {
+    const partialedRight = function (...providedArgs) {
+        const placeholderLength = partialArgs.filter(arg => arg === placeholder).length;
+        const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
+        const remainingArgs = providedArgs.slice(0, rangeLength);
+        let providedArgsIndex = rangeLength;
+        const substitutedArgs = partialArgs
+            .slice()
+            .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg));
+        return func.apply(this, remainingArgs.concat(substitutedArgs));
+    };
+    if (func.prototype) {
+        partialedRight.prototype = Object.create(func.prototype);
+    }
+    return partialedRight;
+}
+const placeholderSymbol = Symbol('partialRight.placeholder');
+partialRight.placeholder = placeholderSymbol;

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/rest.js

@@ -0,0 +1,40 @@
+/**
+ * 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 function rest(func, startIndex = func.length - 1) {
+    return function (...args) {
+        const rest = args.slice(startIndex);
+        const params = args.slice(0, startIndex);
+        while (params.length < startIndex) {
+            params.push(undefined);
+        }
+        return func.apply(this, [...params, rest]);
+    };
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/retry.js

@@ -0,0 +1,41 @@
+import { delay as delayToolkit } from '../promise/delay.js';
+const DEFAULT_DELAY = 0;
+const DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+/**
+ * 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 {number | RetryOptions} [_options] - Either the number of retries or an options object.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ */
+export async function retry(func, _options) {
+    let delay;
+    let retries;
+    let signal;
+    if (typeof _options === 'number') {
+        delay = DEFAULT_DELAY;
+        retries = _options;
+        signal = undefined;
+    }
+    else {
+        delay = _options?.delay ?? DEFAULT_DELAY;
+        retries = _options?.retries ?? DEFAULT_RETRIES;
+        signal = _options?.signal;
+    }
+    let error;
+    for (let attempts = 0; attempts < retries; attempts++) {
+        if (signal?.aborted) {
+            throw error ?? new Error(`The retry operation was aborted due to an abort signal.`);
+        }
+        try {
+            return await func();
+        }
+        catch (err) {
+            error = err;
+            const currentDelay = typeof delay === 'function' ? delay(attempts) : delay;
+            await delayToolkit(currentDelay);
+        }
+    }
+    throw error;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/spread.js

@@ -0,0 +1,21 @@
+/**
+ * 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 function spread(func) {
+    return function (argsArr) {
+        return func.apply(this, argsArr);
+    };
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/throttle.js

@@ -0,0 +1,46 @@
+import { debounce } from './debounce.js';
+/**
+ * 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 function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) {
+    let pendingAt = null;
+    const debounced = debounce(func, throttleMs, { signal, edges });
+    const throttled = function (...args) {
+        if (pendingAt == null) {
+            pendingAt = Date.now();
+        }
+        else {
+            if (Date.now() - pendingAt >= throttleMs) {
+                pendingAt = Date.now();
+                debounced.cancel();
+            }
+        }
+        debounced(...args);
+    };
+    throttled.cancel = debounced.cancel;
+    throttled.flush = debounced.flush;
+    return throttled;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/function/unary.js

@@ -0,0 +1,18 @@
+import { ary } from './ary.js';
+/**
+ * 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 function unary(func) {
+    return ary(func, 1);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/index.js

@@ -0,0 +1,65 @@
+/**
+ * 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';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/clamp.js

@@ -0,0 +1,23 @@
+/**
+ * Clamps a number within the specified bounds.
+ *
+ * This function takes a number and one or two bounds, and returns the number clamped within the specified bounds.
+ * 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} bound1 - The minimum bound to clamp the number, or the maximum bound if bound2 is not provided.
+ * @param {number} [bound2] - The maximum bound to clamp the number. If not provided, the function will only consider bound1 as the upper limit.
+ * @returns {number} The clamped number within the specified bounds.
+ *
+ * @example
+ * const result1 = clamp(10, 5); // result1 will be 5, as 10 is clamped to the bound 5
+ * 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 function clamp(value, bound1, bound2) {
+    if (bound2 == null) {
+        return Math.min(value, bound1);
+    }
+    return Math.min(Math.max(value, bound1), bound2);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/inRange.js

@@ -0,0 +1,24 @@
+/**
+ * Checks if the value is within a specified range.
+ *
+ * @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`.
+ * @throws {Error} Throws an error if the `minimum` is greater or equal than the `maximum`.
+ *
+ * @example
+ * const result1 = inRange(3, 5); // result1 will be true.
+ * const result2 = inRange(1, 2, 5); // result2 will be false.
+ * const result3 = inRange(1, 5, 2); // If the minimum is greater or equal than the maximum, an error is thrown.
+ */
+export function inRange(value, minimum, maximum) {
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('The maximum value must be greater than the minimum value.');
+    }
+    return minimum <= value && value < maximum;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/index.js

@@ -0,0 +1,13 @@
+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';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/mean.js

@@ -0,0 +1,17 @@
+import { sum } from './sum.js';
+/**
+ * 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 function mean(nums) {
+    return sum(nums) / nums.length;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/meanBy.js

@@ -0,0 +1,20 @@
+import { mean } from './mean.js';
+/**
+ * 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 function meanBy(items, getValue) {
+    const nums = items.map(x => getValue(x));
+    return mean(nums);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/median.js

@@ -0,0 +1,35 @@
+/**
+ * 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 function median(nums) {
+    if (nums.length === 0) {
+        return NaN;
+    }
+    const sorted = nums.slice().sort((a, b) => a - b);
+    const middleIndex = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2;
+    }
+    else {
+        return sorted[middleIndex];
+    }
+}