@fedify/fedify 1.6.0-dev.813 → 1.6.0-experiment.0

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

@@ -1,24 +0,0 @@
-/**
- * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function.
- *
- * The `this` context of the returned function is also passed to the functions provided as parameters.
- *
- * @param {Array<(...args: any[]) => any>} funcs The functions to invoke.
- * @returns {(...args: any[]) => any} Returns the new composite function.
- *
- * @example
- * const add = (x: number, y: number) => x + y;
- * const square = (n: number) => n * n;
- *
- * const combined = flow(add, square);
- * console.log(combined(1, 2)); // 9
- */
-export function flow(...funcs) {
-    return function (...args) {
-        let result = funcs.length ? funcs[0].apply(this, args) : args[0];
-        for (let i = 1; i < funcs.length; i++) {
-            result = funcs[i].call(this, result);
-        }
-        return result;
-    };
-}

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

@@ -1,21 +0,0 @@
-import { flow } from './flow.js';
-/**
- * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function.
- *
- * The `this` context of the returned function is also passed to the functions provided as parameters.
- *
- * This method is like `flow` except that it creates a function that invokes the given functions from right to left.
- *
- * @param {(...args: any[]) => any} funcs The functions to invoke.
- * @returns {(...args: any[]) => any} Returns the new composite function.
- *
- * @example
- * const add = (x: number, y: number) => x + y;
- * const square = (n: number) => n * n;
- *
- * const combined = flowRight(square, add);
- * console.log(combined(1, 2)); // 9
- */
-export function flowRight(...funcs) {
-    return flow(...funcs.reverse());
-}

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

@@ -1,22 +0,0 @@
-/**
- * Returns the input value unchanged.
- *
- * @template T - The type of the input value.
- * @param {T} x - The value to be returned.
- * @returns {T} The input value.
- *
- * @example
- * // Returns 5
- * identity(5);
- *
- * @example
- * // Returns 'hello'
- * identity('hello');
- *
- * @example
- * // Returns { key: 'value' }
- * identity({ key: 'value' });
- */
-export function identity(x) {
-    return x;
-}

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

@@ -1,21 +0,0 @@
-export { after } from './after.js';
-export { ary } from './ary.js';
-export { asyncNoop } from './asyncNoop.js';
-export { before } from './before.js';
-export { curry } from './curry.js';
-export { curryRight } from './curryRight.js';
-export { debounce } 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

@@ -1,86 +0,0 @@
-/**
- * Creates a memoized version of the provided function. The memoized function caches
- * results based on the argument it receives, so if the same argument is passed again,
- * it returns the cached result instead of recomputing it.
- *
- * This function works with functions that take zero or just one argument. If your function
- * originally takes multiple arguments, you should refactor it to take a single object or array
- * that combines those arguments.
- *
- * If the argument is not primitive (e.g., arrays or objects), provide a
- * `getCacheKey` function to generate a unique cache key for proper caching.
- *
- * @template F - The type of the function to be memoized.
- * @param {F} fn - The function to be memoized. It should accept a single argument and return a value.
- * @param {MemoizeOptions<Parameters<F>[0], ReturnType<F>>} [options={}] - Optional configuration for the memoization.
- * @param {MemoizeCache<any, V>} [options.cache] - The cache object used to store results. Defaults to a new `Map`.
- * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
- *
- * @returns The memoized function with an additional `cache` property that exposes the internal cache.
- *
- * @example
- * // Example using the default cache
- * const add = (x: number) => x + 10;
- * const memoizedAdd = memoize(add);
- *
- * console.log(memoizedAdd(5)); // 15
- * console.log(memoizedAdd(5)); // 15 (cached result)
- * console.log(memoizedAdd.cache.size); // 1
- *
- * @example
- * // Example using a custom resolver
- * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
- * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
- * console.log(memoizedSum([1, 2])); // 3
- * console.log(memoizedSum([1, 2])); // 3 (cached result)
- * console.log(memoizedSum.cache.size); // 1
- *
- * @example
- * // Example using a custom cache implementation
- * class CustomCache<K, T> implements MemoizeCache<K, T> {
- *   private cache = new Map<K, T>();
- *
- *   set(key: K, value: T): void {
- *     this.cache.set(key, value);
- *   }
- *
- *   get(key: K): T | undefined {
- *     return this.cache.get(key);
- *   }
- *
- *   has(key: K): boolean {
- *     return this.cache.has(key);
- *   }
- *
- *   delete(key: K): boolean {
- *     return this.cache.delete(key);
- *   }
- *
- *   clear(): void {
- *     this.cache.clear();
- *   }
- *
- *   get size(): number {
- *     return this.cache.size;
- *   }
- * }
- * const customCache = new CustomCache<string, number>();
- * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
- * console.log(memoizedSumWithCustomCache([1, 2])); // 3
- * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
- * console.log(memoizedAddWithCustomCache.cache.size); // 1
- */
-export 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

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

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

@@ -1,10 +0,0 @@
-/**
- * A no-operation function that does nothing.
- * This can be used as a placeholder or default function.
- *
- * @example
- * noop(); // Does nothing
- *
- * @returns {void} This function does not return anything.
- */
-export function noop() { }

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

@@ -1,28 +0,0 @@
-/**
- * Creates a function that is restricted to invoking the provided function `func` once.
- * Repeated calls to the function will return the value from the first invocation.
- *
- * @template F - The type of function.
- * @param {F} 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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,17 +0,0 @@
-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;
-}