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

package/esm/deno.js

@@ -1,110 +0,0 @@
-export default {
-    "name": "@fedify/fedify",
-    "version": "1.6.0-dev.814+26348fc2",
-    "license": "MIT",
-    "exports": {
-        ".": "./mod.ts",
-        "./compat": "./compat/mod.ts",
-        "./federation": "./federation/mod.ts",
-        "./nodeinfo": "./nodeinfo/mod.ts",
-        "./runtime": "./runtime/mod.ts",
-        "./sig": "./sig/mod.ts",
-        "./vocab": "./vocab/mod.ts",
-        "./webfinger": "./webfinger/mod.ts",
-        "./x/denokv": "./x/denokv.ts",
-        "./x/fresh": "./x/fresh.ts",
-        "./x/hono": "./x/hono.ts",
-        "./x/sveltekit": "./x/sveltekit.ts"
-    },
-    "imports": {
-        "@cfworker/json-schema": "npm:@cfworker/json-schema@^2.0.1",
-        "@deno/dnt": "jsr:@deno/dnt@0.41.3",
-        "@es-toolkit/es-toolkit": "jsr:@es-toolkit/es-toolkit@^1.38.0",
-        "@hugoalh/http-header-link": "jsr:@hugoalh/http-header-link@^1.0.2",
-        "@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0",
-        "@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.27.0",
-        "@phensley/language-tag": "npm:@phensley/language-tag@^1.9.0",
-        "@std/assert": "jsr:@std/assert@^0.226.0",
-        "@std/testing": "jsr:@std/testing@^0.224.0",
-        "@std/url": "jsr:@std/url@^0.225.1",
-        "@std/yaml": "jsr:@std/yaml@^0.224.3",
-        "asn1js": "npm:asn1js@^3.0.5",
-        "byte-encodings": "npm:byte-encodings@^1.0.11",
-        "fast-check": "npm:fast-check@^3.22.0",
-        "json-canon": "npm:json-canon@^1.0.1",
-        "jsonld": "npm:jsonld@^8.3.2",
-        "mock_fetch": "jsr:@hongminhee/deno-mock-fetch@^0.3.2",
-        "multicodec": "npm:multicodec@^3.2.1",
-        "pkijs": "npm:pkijs@^3.2.4",
-        "structured-field-values": "npm:structured-field-values@^2.0.4",
-        "uri-template-router": "npm:uri-template-router@^0.0.17",
-        "url-template": "npm:url-template@^3.1.1"
-    },
-    "include": [
-        "vocab/vocab.ts"
-    ],
-    "exclude": [
-        ".dnt-import-map.json",
-        "apidoc/",
-        "codegen/schema.yaml",
-        "npm/",
-        "vocab/*.yaml",
-        "!vocab/vocab.ts"
-    ],
-    "tasks": {
-        "codegen": "deno run --allow-read --allow-write --check codegen/main.ts vocab/ ../runtime/ > vocab/vocab.ts && deno fmt vocab/vocab.ts && deno cache vocab/vocab.ts && deno check vocab/vocab.ts",
-        "check-version": "deno run ../cli/scripts/check_version.ts",
-        "cache": {
-            "command": "deno cache mod.ts",
-            "dependencies": [
-                "check-version",
-                "codegen"
-            ]
-        },
-        "check": {
-            "command": "deno fmt --check && deno lint && deno check */*.ts",
-            "dependencies": [
-                "codegen"
-            ]
-        },
-        "test": {
-            "command": "deno test --check --doc --allow-read --allow-write --allow-env --unstable-kv --trace-leaks --parallel",
-            "dependencies": [
-                "codegen"
-            ]
-        },
-        "coverage": "deno task test --clean --coverage && deno coverage --html coverage",
-        "bench": {
-            "command": "deno bench --allow-read --allow-write --allow-net --allow-env --allow-run --unstable-kv",
-            "dependencies": [
-                "codegen"
-            ]
-        },
-        "apidoc": {
-            "command": "deno doc --html --name=Fedify --output=apidoc/ mod.ts",
-            "dependencies": [
-                "codegen"
-            ]
-        },
-        "publish": {
-            "command": "deno publish",
-            "dependencies": [
-                "codegen"
-            ]
-        },
-        "dnt": {
-            "command": "deno run -A dnt.ts",
-            "dependencies": [
-                "codegen"
-            ]
-        },
-        "test-all": {
-            "command": "cd npm/ && bun run ./test_runner.js && cd ../",
-            "dependencies": [
-                "check",
-                "test",
-                "dnt"
-            ]
-        }
-    }
-};

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

@@ -1,9 +0,0 @@
-export function compareValues(a, b, order) {
-    if (a < b) {
-        return order === 'asc' ? -1 : 1;
-    }
-    if (a > b) {
-        return order === 'asc' ? 1 : -1;
-    }
-    return 0;
-}

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

@@ -1,28 +0,0 @@
-/**
- * Retrieves elements from an array at the specified indices.
- *
- * This function supports negative indices, which count from the end of the array.
- *
- * @template T
- * @param {readonly T[]} arr - The array to retrieve elements from.
- * @param {number[]} indices - An array of indices specifying the positions of elements to retrieve.
- * @returns {T[]} A new array containing the elements at the specified indices.
- *
- * @example
- * const numbers = [10, 20, 30, 40, 50];
- * const result = at(numbers, [1, 3, 4]);
- * console.log(result); // [20, 40, 50]
- */
-export function at(arr, indices) {
-    const result = new Array(indices.length);
-    const length = arr.length;
-    for (let i = 0; i < indices.length; i++) {
-        let index = indices[i];
-        index = Number.isInteger(index) ? index : Math.trunc(index) || 0;
-        if (index < 0) {
-            index += length;
-        }
-        result[i] = arr[index];
-    }
-    return result;
-}

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

@@ -1,36 +0,0 @@
-/**
- * Splits an array into smaller arrays of a specified length.
- *
- * This function takes an input array and divides it into multiple smaller arrays,
- * each of a specified length. If the input array cannot be evenly divided,
- * the final sub-array will contain the remaining elements.
- *
- * @template T The type of elements in the array.
- * @param {T[]} arr - The array to be chunked into smaller arrays.
- * @param {number} size - The size of each smaller array. Must be a positive integer.
- * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.
- * @throws {Error} Throws an error if `size` is not a positive integer.
- *
- * @example
- * // Splits an array of numbers into sub-arrays of length 2
- * chunk([1, 2, 3, 4, 5], 2);
- * // Returns: [[1, 2], [3, 4], [5]]
- *
- * @example
- * // Splits an array of strings into sub-arrays of length 3
- * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
- * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
- */
-export function chunk(arr, size) {
-    if (!Number.isInteger(size) || size <= 0) {
-        throw new Error('Size must be an integer greater than zero.');
-    }
-    const chunkLength = Math.ceil(arr.length / size);
-    const result = Array(chunkLength);
-    for (let index = 0; index < chunkLength; index++) {
-        const start = index * size;
-        const end = start + size;
-        result[index] = arr.slice(start, end);
-    }
-    return result;
-}

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

@@ -1,21 +0,0 @@
-/**
- * Removes falsey values (false, null, 0, -0, 0n, '', undefined, NaN) from an array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The input array to remove falsey values.
- * @returns {Array<Exclude<T, false | null | 0 | 0n | '' | undefined>>} - A new array with all falsey values removed.
- *
- * @example
- * compact([0, -0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
- * Returns: [1, 2, 3, 4, 5]
- */
-export function compact(arr) {
-    const result = [];
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        if (item) {
-            result.push(item);
-        }
-    }
-    return result;
-}

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

@@ -1,36 +0,0 @@
-/**
- * Count the occurrences of each item in an array
- * based on a transformation function.
- *
- * This function takes an array and a transformation function
- * that converts each item in the array to a key. It then
- * counts the occurrences of each transformed item and returns
- * an object with the transformed items as keys and the counts
- * as values.
- *
- * @template T - The type of the items in the input array.
- * @template K - The type of keys.
- * @param {T[]} arr - The input array to count occurrences.
- * @param {(item: T) => K} mapper - The transformation function that maps each item to a key.
- * @returns {Record<K, number>} An object containing the transformed items as keys and the
- * counts as values.
- *
- * @example
- * const array = ['a', 'b', 'c', 'a', 'b', 'a'];
- * const result = countBy(array, x => x);
- * // result will be { a: 3, b: 2, c: 1 }
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
- * // result will be { odd: 3, even: 2 }
- */
-export function countBy(arr, mapper) {
-    const result = {};
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        const key = mapper(item);
-        result[key] = (result[key] ?? 0) + 1;
-    }
-    return result;
-}

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

@@ -1,26 +0,0 @@
-/**
- * Computes the difference between two arrays.
- *
- * This function takes two arrays and returns a new array containing the elements
- * that are present in the first array but not in the second array. It effectively
- * filters out any elements from the first array that also appear in the second array.
- *
- * @template T
- * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array
- * from which elements will be compared and filtered.
- * @param {T[]} secondArr - The array containing elements to be excluded from the first array.
- * Each element in this array will be checked against the first array, and if a match is found,
- * that element will be excluded from the result.
- * @returns {T[]} A new array containing the elements that are present in the first array but not
- * in the second array.
- *
- * @example
- * const array1 = [1, 2, 3, 4, 5];
- * const array2 = [2, 4];
- * const result = difference(array1, array2);
- * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
- */
-export function difference(firstArr, secondArr) {
-    const secondSet = new Set(secondArr);
-    return firstArr.filter(item => !secondSet.has(item));
-}

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

@@ -1,38 +0,0 @@
-/**
- * Computes the difference between two arrays after mapping their elements through a provided function.
- *
- * This function takes two arrays and a mapper function. It returns a new array containing the elements
- * that are present in the first array but not in the second array, based on the identity calculated
- * by the mapper function.
- *
- * Essentially, it filters out any elements from the first array that, when
- * mapped, match an element in the mapped version of the second array.
- *
- * @template T, U
- * @param {T[]} firstArr - The primary array from which to derive the difference.
- * @param {U[]} secondArr - The array containing elements to be excluded from the first array.
- * @param {(value: T | U) => unknown} mapper - The function to map the elements of both arrays. This function
- * is applied to each element in both arrays, and the comparison is made based on the mapped values.
- * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding
- * mapped identity in the second array.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [{ id: 2 }, { id: 4 }];
- * const mapper = item => item.id;
- * const result = differenceBy(array1, array2, mapper);
- * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [2, 4];
- * const mapper = item => (typeof item === 'object' ? item.id : item);
- * const result = differenceBy(array1, array2, mapper);
- * // result will be [{ id: 1 }, { id: 3 }] since 2 is present in both arrays after mapping, and is excluded from the result.
- */
-export function differenceBy(firstArr, secondArr, mapper) {
-    const mappedSecondSet = new Set(secondArr.map(item => mapper(item)));
-    return firstArr.filter(item => {
-        return !mappedSecondSet.has(mapper(item));
-    });
-}

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

@@ -1,35 +0,0 @@
-/**
- * Computes the difference between two arrays based on a custom equality function.
- *
- * This function takes two arrays and a custom comparison function. It returns a new array containing
- * the elements that are present in the first array but not in the second array. The comparison to determine
- * if elements are equal is made using the provided custom function.
- *
- * @template T, U
- * @param {T[]} firstArr - The array from which to get the difference.
- * @param {U[]} secondArr - The array containing elements to exclude from the first array.
- * @param {(x: T, y: U) => boolean} areItemsEqual - A function to determine if two items are equal.
- * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array
- * according to the custom equality function.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [{ id: 2 }, { id: 4 }];
- * const areItemsEqual = (a, b) => a.id === b.id;
- * const result = differenceWith(array1, array2, areItemsEqual);
- * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [2, 4];
- * const areItemsEqual = (a, b) => a.id === b;
- * const result = differenceWith(array1, array2, areItemsEqual);
- * // result will be [{ id: 1 }, { id: 3 }] since the element with id 2 is considered equal to the second array's element and is excluded from the result.
- */
-export function differenceWith(firstArr, secondArr, areItemsEqual) {
-    return firstArr.filter(firstItem => {
-        return secondArr.every(secondItem => {
-            return !areItemsEqual(firstItem, secondItem);
-        });
-    });
-}

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

@@ -1,20 +0,0 @@
-/**
- * Removes a specified number of elements from the beginning of an array and returns the rest.
- *
- * This function takes an array and a number, and returns a new array with the specified number
- * of elements removed from the start.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
- * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
- * @returns {T[]} A new array with the specified number of elements removed from the start.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const result = drop(array, 2);
- * // result will be [3, 4, 5] since the first two elements are dropped.
- */
-export function drop(arr, itemsCount) {
-    itemsCount = Math.max(itemsCount, 0);
-    return arr.slice(itemsCount);
-}

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

@@ -1,23 +0,0 @@
-/**
- * Removes a specified number of elements from the end of an array and returns the rest.
- *
- * This function takes an array and a number, and returns a new array with the specified number
- * of elements removed from the end.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
- * @param {number} itemsCount - The number of elements to drop from the end of the array.
- * @returns {T[]} A new array with the specified number of elements removed from the end.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const result = dropRight(array, 2);
- * // result will be [1, 2, 3] since the last two elements are dropped.
- */
-export function dropRight(arr, itemsCount) {
-    itemsCount = Math.min(-itemsCount, 0);
-    if (itemsCount === 0) {
-        return arr.slice();
-    }
-    return arr.slice(0, itemsCount);
-}

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

@@ -1,26 +0,0 @@
-/**
- * Removes elements from the end of an array until the predicate returns false.
- *
- * This function iterates over an array from the end and drops elements until the provided
- * predicate function returns false. It then returns a new array with the remaining elements.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
- * @param {(item: T, index: number, arr: T[]) => boolean} canContinueDropping - A predicate function that determines
- * whether to continue dropping elements. The function is called with each element from the end,
- * and dropping continues as long as it returns true.
- * @returns {T[]} A new array with the elements remaining after the predicate returns false.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const result = dropRightWhile(array, x => x > 3);
- * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
- */
-export function dropRightWhile(arr, canContinueDropping) {
-    for (let i = arr.length - 1; i >= 0; i--) {
-        if (!canContinueDropping(arr[i], i, arr)) {
-            return arr.slice(0, i + 1);
-        }
-    }
-    return [];
-}

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

@@ -1,25 +0,0 @@
-/**
- * Removes elements from the beginning of an array until the predicate returns false.
- *
- * This function iterates over an array and drops elements from the start until the provided
- * predicate function returns false. It then returns a new array with the remaining elements.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to drop elements.
- * @param {(item: T, index: number, arr: T[]) => boolean} canContinueDropping - A predicate function that determines
- * whether to continue dropping elements. The function is called with each element, and dropping
- * continues as long as it returns true.
- * @returns {T[]} A new array with the elements remaining after the predicate returns false.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const result = dropWhile(array, x => x < 3);
- * // result will be [3, 4, 5] since elements less than 3 are dropped.
- */
-export function dropWhile(arr, canContinueDropping) {
-    const dropEndIndex = arr.findIndex((item, index, arr) => !canContinueDropping(item, index, arr));
-    if (dropEndIndex === -1) {
-        return [];
-    }
-    return arr.slice(dropEndIndex);
-}

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

@@ -1,37 +0,0 @@
-/**
- * Fills elements of an array with a specified value from the start position up to, but not including, the end position.
- *
- * This function mutates the original array and replaces its elements with the provided value, starting from the specified
- * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
- * entire array.
- *
- * @template T, U
- * @param {Array<T | U>} array - The array to fill.
- * @param {U} value - The value to fill the array with.
- * @param {number} [start=0] - The start position. Defaults to 0.
- * @param {number} [end=arr.length] - The end position. Defaults to the array's length.
- * @returns {Array<T | U>} The array with the filled values.
- *
- * @example
- * const array = [1, 2, 3];
- * const result = fill(array, 'a');
- * // => ['a', 'a', 'a']
- *
- * const result = fill(Array(3), 2);
- * // => [2, 2, 2]
- *
- * const result = fill([4, 6, 8, 10], '*', 1, 3);
- * // => [4, '*', '*', 10]
- *
- * const result = fill(array, '*', -2, -1);
- * // => [1, '*', 3]
- */
-export function fill(array, value, start = 0, end = array.length) {
-    const length = array.length;
-    const finalStart = Math.max(start >= 0 ? start : length + start, 0);
-    const finalEnd = Math.min(end >= 0 ? end : length + end, length);
-    for (let i = finalStart; i < finalEnd; i++) {
-        array[i] = value;
-    }
-    return array;
-}

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

@@ -1,24 +0,0 @@
-import { flatten } from './flatten.js';
-/**
- * Maps each element in the array using the iteratee function and flattens the result up to the specified depth.
- *
- * @template T - The type of elements within the array.
- * @template U - The type of elements within the returned array from the iteratee function.
- * @template D - The depth to which the array should be flattened.
- * @param {T[]} arr - The array to flatten.
- * @param {(item: T) => U} iteratee - The function that produces the new array elements.
- * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
- * @returns {Array<FlatArray<U[], D>>} The new array with the mapped and flattened elements.
- *
- * @example
- * const arr = [1, 2, 3];
- *
- * flatMap(arr, (item: number) => [item, item]);
- * // [1, 1, 2, 2, 3, 3]
- *
- * flatMap(arr, (item: number) => [[item, item]], 2);
- * // [1, 1, 2, 2, 3, 3]
- */
-export function flatMap(arr, iteratee, depth = 1) {
-    return flatten(arr.map(item => iteratee(item)), depth);
-}

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

@@ -1,17 +0,0 @@
-import { flattenDeep } from './flattenDeep.js';
-/**
- * Recursively maps each element in an array using a provided iteratee function and then deeply flattens the resulting array.
- *
- * @template T - The type of elements within the array.
- * @template U - The type of elements within the returned array from the iteratee function.
- * @param {T[]} arr - The array to flatten.
- * @param {(item: T) => U} iteratee - The function that produces the new array elements.
- * @returns {Array<ExtractNestedArrayType<U>>} A new array that has been flattened.
- *
- * @example
- * const result = flatMapDeep([1, 2, 3], n => [[n, n]]);
- * // [1, 1, 2, 2, 3, 3]
- */
-export function flatMapDeep(arr, iteratee) {
-    return flattenDeep(arr.map((item) => iteratee(item)));
-}

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

@@ -1,33 +0,0 @@
-/**
- * Flattens an array up to the specified depth.
- *
- * @template T - The type of elements within the array.
- * @template D - The depth to which the array should be flattened.
- * @param {T[]} arr - The array to flatten.
- * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
- * @returns {Array<FlatArray<T[], D>>} A new array that has been flattened.
- *
- * @example
- * const arr = flatten([1, [2, 3], [4, [5, 6]]], 1);
- * // Returns: [1, 2, 3, 4, [5, 6]]
- *
- * const arr = flatten([1, [2, 3], [4, [5, 6]]], 2);
- * // Returns: [1, 2, 3, 4, 5, 6]
- */
-export function flatten(arr, depth = 1) {
-    const result = [];
-    const flooredDepth = Math.floor(depth);
-    const recursive = (arr, currentDepth) => {
-        for (let i = 0; i < arr.length; i++) {
-            const item = arr[i];
-            if (Array.isArray(item) && currentDepth < flooredDepth) {
-                recursive(item, currentDepth + 1);
-            }
-            else {
-                result.push(item);
-            }
-        }
-    };
-    recursive(arr, 0);
-    return result;
-}

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

@@ -1,15 +0,0 @@
-import { flatten } from './flatten.js';
-/**
- * Flattens all depths of a nested array.
- *
- * @template T - The type of elements within the array.
- * @param {T[]} arr - The array to flatten.
- * @returns {Array<ExtractNestedArrayType<T>>} A new array that has been flattened.
- *
- * @example
- * const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]);
- * // Returns: [1, 2, 3, 4, 5, 6]
- */
-export function flattenDeep(arr) {
-    return flatten(arr, Infinity);
-}

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

@@ -1,28 +0,0 @@
-/**
- * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to iterate over.
- * @param {(value: T, index: number, arr: T[]) => void} callback - The function invoked per iteration.
- * The callback function receives three arguments:
- *  - 'value': The current element being processed in the array.
- *  - 'index': The index of the current element being processed in the array.
- *  - 'arr': The array 'forEachRight' was called upon.
- *
- * @example
- * const array = [1, 2, 3];
- * const result: number[] = [];
- *
- * // Use the forEachRight function to iterate through the array and add each element to the result array.
- * forEachRight(array, (value) => {
- *  result.push(value);
- * })
- *
- * console.log(result) // Output: [3, 2, 1]
- */
-export function forEachRight(arr, callback) {
-    for (let i = arr.length - 1; i >= 0; i--) {
-        const element = arr[i];
-        callback(element, i, arr);
-    }
-}

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

@@ -1,44 +0,0 @@
-/**
- * Groups the elements of an array based on a provided key-generating function.
- *
- * This function takes an array and a function that generates a key from each element. It returns
- * an object where the keys are the generated keys and the values are arrays of elements that share
- * the same key.
- *
- * @template T - The type of elements in the array.
- * @template K - The type of keys.
- * @param {T[]} arr - The array to group.
- * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
- * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that
- * share that key.
- *
- * @example
- * const array = [
- *   { category: 'fruit', name: 'apple' },
- *   { category: 'fruit', name: 'banana' },
- *   { category: 'vegetable', name: 'carrot' }
- * ];
- * const result = groupBy(array, item => item.category);
- * // result will be:
- * // {
- * //   fruit: [
- * //     { category: 'fruit', name: 'apple' },
- * //     { category: 'fruit', name: 'banana' }
- * //   ],
- * //   vegetable: [
- * //     { category: 'vegetable', name: 'carrot' }
- * //   ]
- * // }
- */
-export function groupBy(arr, getKeyFromItem) {
-    const result = {};
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        const key = getKeyFromItem(item);
-        if (!Object.hasOwn(result, key)) {
-            result[key] = [];
-        }
-        result[key].push(item);
-    }
-    return result;
-}