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

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

@@ -0,0 +1,47 @@
+/**
+ * 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 declare function forEachRight<T>(arr: T[], callback: (value: T, index: number, arr: T[]) => void): void;
+/**
+ * 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 declare function forEachRight<T>(arr: readonly T[], callback: (value: T, index: number, arr: readonly T[]) => void): void;
+//# sourceMappingURL=forEachRight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"forEachRight.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/forEachRight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;AACvG;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,GAAG,EAAE,SAAS,CAAC,EAAE,EACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,GAC7D,IAAI,CAAC"}

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

@@ -0,0 +1,34 @@
+/**
+ * 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 declare function groupBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;
+//# sourceMappingURL=groupBy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"groupBy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/groupBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAenH"}

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

@@ -0,0 +1,33 @@
+/**
+ * Returns the first element of an array.
+ *
+ * This function takes an array and returns the first element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {[T, ...T[]]} arr - A non-empty array from which to get the first element.
+ * @returns {T} The first element of the array.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * const firstElement = head(arr);
+ * // firstElement will be 1
+ */
+export declare function head<T>(arr: readonly [T, ...T[]]): T;
+/**
+ * Returns the first element of an array or `undefined` if the array is empty.
+ *
+ * This function takes an array and returns the first element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to get the first element.
+ * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const emptyArr: number[] = [];
+ * const noElement = head(emptyArr);
+ * // noElement will be undefined
+ */
+export declare function head<T>(arr: readonly T[]): T | undefined;
+//# sourceMappingURL=head.d.ts.map

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

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

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

@@ -0,0 +1,61 @@
+export { at } from './at.js';
+export { chunk } from './chunk.js';
+export { compact } from './compact.js';
+export { countBy } from './countBy.js';
+export { difference } from './difference.js';
+export { differenceBy } from './differenceBy.js';
+export { differenceWith } from './differenceWith.js';
+export { drop } from './drop.js';
+export { dropRight } from './dropRight.js';
+export { dropRightWhile } from './dropRightWhile.js';
+export { dropWhile } from './dropWhile.js';
+export { fill } from './fill.js';
+export { flatMap } from './flatMap.js';
+export { flatMapDeep } from './flatMapDeep.js';
+export { flatten } from './flatten.js';
+export { flattenDeep } from './flattenDeep.js';
+export { forEachRight } from './forEachRight.js';
+export { groupBy } from './groupBy.js';
+export { head } from './head.js';
+export { initial } from './initial.js';
+export { intersection } from './intersection.js';
+export { intersectionBy } from './intersectionBy.js';
+export { intersectionWith } from './intersectionWith.js';
+export { isSubset } from './isSubset.js';
+export { isSubsetWith } from './isSubsetWith.js';
+export { keyBy } from './keyBy.js';
+export { last } from './last.js';
+export { maxBy } from './maxBy.js';
+export { minBy } from './minBy.js';
+export { orderBy } from './orderBy.js';
+export { partition } from './partition.js';
+export { pull } from './pull.js';
+export { pullAt } from './pullAt.js';
+export { remove } from './remove.js';
+export { sample } from './sample.js';
+export { sampleSize } from './sampleSize.js';
+export { shuffle } from './shuffle.js';
+export { sortBy } from './sortBy.js';
+export { tail } from './tail.js';
+export { take } from './take.js';
+export { takeRight } from './takeRight.js';
+export { takeRightWhile } from './takeRightWhile.js';
+export { takeWhile } from './takeWhile.js';
+export { toFilled } from './toFilled.js';
+export { union } from './union.js';
+export { unionBy } from './unionBy.js';
+export { unionWith } from './unionWith.js';
+export { uniq } from './uniq.js';
+export { uniqBy } from './uniqBy.js';
+export { uniqWith } from './uniqWith.js';
+export { unzip } from './unzip.js';
+export { unzipWith } from './unzipWith.js';
+export { windowed } from './windowed.js';
+export { without } from './without.js';
+export { xor } from './xor.js';
+export { xorBy } from './xorBy.js';
+export { xorWith } from './xorWith.js';
+export { zip } from './zip.js';
+export { zipObject } from './zipObject.js';
+export { zipWith } from './zipWith.js';
+//# sourceMappingURL=index.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/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/array/index.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,53 @@
+/**
+ * Returns an empty array when the input is a tuple containing exactly one element.
+ *
+ * @template T The type of the single element.
+ * @param {[T]} arr - A tuple containing exactly one element.
+ * @returns {[]} An empty array since there is only one element.
+ *
+ * @example
+ * const array = [100] as const;
+ * const result = initial(array);
+ * // result will be []
+ */
+export declare function initial<T>(arr: readonly [T]): [];
+/**
+ * Returns an empty array when the input array is empty.
+ *
+ * @returns {[]} Always returns an empty array for an empty input.
+ *
+ * @example
+ * const array = [] as const;
+ * const result = initial(array);
+ * // result will be []
+ */
+export declare function initial(arr: readonly []): [];
+/**
+ * Returns a new array containing all elements except the last one from a tuple with multiple elements.
+ *
+ * @template T The types of the initial elements.
+ * @template U The type of the last element in the tuple.
+ * @param {[...T[], U]} arr - A tuple with one or more elements.
+ * @returns {T[]} A new array containing all but the last element of the tuple.
+ *
+ * @example
+ * const array = ['apple', 'banana', 'cherry'] as const;
+ * const result = initial(array);
+ * // result will be ['apple', 'banana']
+ */
+export declare function initial<T, U>(arr: readonly [...T[], U]): T[];
+/**
+ * Returns a new array containing all elements except the last one from the input array.
+ * If the input array is empty or has only one element, the function returns an empty array.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} arr - The input array.
+ * @returns {T[]} A new array containing all but the last element of the input array.
+ *
+ * @example
+ * const arr = [1, 2, 3, 4];
+ * const result = initial(arr);
+ * // result will be [1, 2, 3]
+ */
+export declare function initial<T>(arr: readonly T[]): T[];
+//# sourceMappingURL=initial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"initial.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/initial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAElD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;AAE9C;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC"}

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

@@ -0,0 +1,20 @@
+/**
+ * Returns the intersection of two arrays.
+ *
+ * This function takes two arrays and returns a new array containing the elements that are
+ * present in both arrays. It effectively filters out any elements from the first array that
+ * are not found in the second array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {T[]} secondArr - The second array to compare.
+ * @returns {T[]} A new array containing the elements that are present in both arrays.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [3, 4, 5, 6, 7];
+ * const result = intersection(array1, array2);
+ * // result will be [3, 4, 5] since these elements are in both arrays.
+ */
+export declare function intersection<T>(firstArr: readonly T[], secondArr: readonly T[]): T[];
+//# sourceMappingURL=intersection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/intersection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAMpF"}

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

@@ -0,0 +1,35 @@
+/**
+ * Returns the intersection of two arrays based on a mapping function.
+ *
+ * This function takes two arrays and a mapping function. It returns a new array containing
+ * the elements from the first array that, when mapped using the provided function, have matching
+ * mapped elements in the second array. It effectively filters out any elements from the first array
+ * that do not have corresponding mapped values in the second array.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(item: T | U) => unknown} mapper - A function to map the elements of both arrays for comparison.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values 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 = intersectionBy(array1, array2, mapper);
+ * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
+ *
+ * @example
+ * const array1 = [
+ *   { id: 1, name: 'jane' },
+ *   { id: 2, name: 'amy' },
+ *   { id: 3, name: 'michael' },
+ * ];
+ * const array2 = [2, 4];
+ * const mapper = item => (typeof item === 'object' ? item.id : item);
+ * const result = intersectionBy(array1, array2, mapper);
+ * // result will be [{ id: 2, name: 'amy' }] since only this element has a matching id that is equal to seconds array's element.
+ */
+export declare function intersectionBy<T, U>(firstArr: readonly T[], secondArr: readonly U[], mapper: (item: T | U) => unknown): T[];
+//# sourceMappingURL=intersectionBy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersectionBy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/intersectionBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EACjC,QAAQ,EAAE,SAAS,CAAC,EAAE,EACtB,SAAS,EAAE,SAAS,CAAC,EAAE,EACvB,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,OAAO,GAC/B,CAAC,EAAE,CAGL"}

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

@@ -0,0 +1,36 @@
+/**
+ * Returns the intersection of two arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom equality function. It returns a new array containing
+ * the elements from the first array that have matching elements in the second array, as determined
+ * by the custom equality function. It effectively filters out any elements from the first array that
+ * do not have corresponding matches in the second array according to the equality function.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
+ * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding matches 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 = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
+ *
+ * @example
+ * const array1 = [
+ *   { id: 1, name: 'jane' },
+ *   { id: 2, name: 'amy' },
+ *   { id: 3, name: 'michael' },
+ * ];
+ * const array2 = [2, 4];
+ * const areItemsEqual = (a, b) => a.id === b;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element.
+ */
+export declare function intersectionWith<T, U>(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[];
+//# sourceMappingURL=intersectionWith.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersectionWith.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/intersectionWith.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,QAAQ,EAAE,SAAS,CAAC,EAAE,EACtB,SAAS,EAAE,SAAS,CAAC,EAAE,EACvB,aAAa,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GACrC,CAAC,EAAE,CAML"}

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

@@ -0,0 +1,25 @@
+/**
+ * Checks if the `subset` array is entirely contained within the `superset` array.
+ *
+ *
+ * @template T - The type of elements contained in the arrays.
+ * @param {T[]} superset - The array that may contain all elements of the subset.
+ * @param {T[]} subset - The array to check against the superset.
+ * @returns {boolean} - Returns `true` if all elements of the `subset` are present in the `superset`, otherwise returns `false`.
+ *
+ * @example
+ * ```typescript
+ * const superset = [1, 2, 3, 4, 5];
+ * const subset = [2, 3, 4];
+ * isSubset(superset, subset); // true
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const superset = ['a', 'b', 'c'];
+ * const subset = ['a', 'd'];
+ * isSubset(superset, subset); // false
+ * ```
+ */
+export declare function isSubset<T>(superset: readonly T[], subset: readonly T[]): boolean;
+//# sourceMappingURL=isSubset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isSubset.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/isSubset.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,OAAO,CAEjF"}

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

@@ -0,0 +1,32 @@
+/**
+ * Checks if the `subset` array is entirely contained within the `superset` array based on a custom equality function.
+ *
+ * This function takes two arrays and a custom comparison function. It returns a boolean indicating
+ * whether all elements in the subset array are present in the superset array, as determined by the provided
+ * custom equality function.
+ *
+ * @template T - The type of elements contained in the arrays.
+ * @param {T[]} superset - The array that may contain all elements of the subset.
+ * @param {T[]} subset - The array to check against the superset.
+ * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.
+ * @returns {boolean} - Returns `true` if all elements of the subset are present in the superset
+ * according to the custom equality function, otherwise returns `false`.
+ *
+ * @example
+ * ```typescript
+ * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const subset = [{ id: 2 }, { id: 1 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * isSubsetWith(superset, subset, areItemsEqual); // true
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const subset = [{ id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * isSubsetWith(superset, subset, areItemsEqual); // false
+ * ```
+ */
+export declare function isSubsetWith<T>(superset: readonly T[], subset: readonly T[], areItemsEqual: (x: T, y: T) => boolean): boolean;
+//# sourceMappingURL=isSubsetWith.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isSubsetWith.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/isSubsetWith.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,QAAQ,EAAE,SAAS,CAAC,EAAE,EACtB,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,aAAa,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GACrC,OAAO,CAET"}

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

@@ -0,0 +1,29 @@
+/**
+ * Maps each element 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 the corresponding elements.
+ * If there are multiple elements generating the same key, the last element among them is used
+ * as the value.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The type of keys.
+ * @param {T[]} arr - The array of elements to be mapped.
+ * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = keyBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: { category: 'fruit', name: 'banana' },
+ * //   vegetable: { category: 'vegetable', name: 'carrot' }
+ * // }
+ */
+export declare function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
+//# sourceMappingURL=keyBy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyBy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/keyBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAU/G"}

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

@@ -0,0 +1,47 @@
+/**
+ * Returns the last element of an array.
+ *
+ * This function takes an array and returns the last element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * Unlike some implementations, this function is optimized for performance
+ * by directly accessing the last index of the array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {[...T[], T]} arr - The array from which to get the last element.
+ * @returns {T} The last element of the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * const lastElement = last(arr);
+ * // lastElement will be 3
+ *
+ * const emptyArr: number[] = [];
+ * const noElement = last(emptyArr);
+ * // noElement will be undefined
+ */
+export declare function last<T>(arr: readonly [...T[], T]): T;
+/**
+ * Returns the last element of an array.
+ *
+ * This function takes an array and returns the last element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * Unlike some implementations, this function is optimized for performance
+ * by directly accessing the last index of the array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to get the last element.
+ * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * const lastElement = last(arr);
+ * // lastElement will be 3
+ *
+ * const emptyArr: number[] = [];
+ * const noElement = last(emptyArr);
+ * // noElement will be undefined
+ */
+export declare function last<T>(arr: readonly T[]): T | undefined;
+//# sourceMappingURL=last.d.ts.map

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

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

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

@@ -0,0 +1,44 @@
+/**
+ * Finds the element in an array that has the maximum value when applying
+ * the `getValue` function to each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {[T, ...T[]]} items The nonempty array of elements to search.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {T} The element with the maximum value as determined by the `getValue` function.
+ * @example
+ * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
+ * maxBy([], x => x.a); // Returns: undefined
+ * maxBy(
+ *   [
+ *     { name: 'john', age: 30 },
+ *     { name: 'jane', age: 28 },
+ *     { name: 'joe', age: 26 },
+ *   ],
+ *   x => x.age
+ * ); // Returns: { name: 'john', age: 30 }
+ */
+export declare function maxBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+/**
+ * Finds the element in an array that has the maximum value when applying
+ * the `getValue` function to each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items The array of elements to search.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function,
+ * or `undefined` if the array is empty.
+ * @example
+ * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
+ * maxBy([], x => x.a); // Returns: undefined
+ * maxBy(
+ *   [
+ *     { name: 'john', age: 30 },
+ *     { name: 'jane', age: 28 },
+ *     { name: 'joe', age: 26 },
+ *   ],
+ *   x => x.age
+ * ); // Returns: { name: 'john', age: 30 }
+ */
+export declare function maxBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
+//# sourceMappingURL=maxBy.d.ts.map

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

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

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

@@ -0,0 +1,44 @@
+/**
+ * Finds the element in an array that has the minimum value when applying
+ * the `getValue` function to each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {[T, ...T[]]} items The nonempty array of elements to search.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {T} The element with the minimum value as determined by the `getValue` function.
+ * @example
+ * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
+ * minBy([], x => x.a); // Returns: undefined
+ * minBy(
+ *   [
+ *     { name: 'john', age: 30 },
+ *     { name: 'jane', age: 28 },
+ *     { name: 'joe', age: 26 },
+ *   ],
+ *   x => x.age
+ * ); // Returns: { name: 'joe', age: 26 }
+ */
+export declare function minBy<T>(items: readonly [T, ...T[]], getValue: (element: T) => number): T;
+/**
+ * Finds the element in an array that has the minimum value when applying
+ * the `getValue` function to each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items The array of elements to search.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function,
+ * or `undefined` if the array is empty.
+ * @example
+ * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
+ * minBy([], x => x.a); // Returns: undefined
+ * minBy(
+ *   [
+ *     { name: 'john', age: 30 },
+ *     { name: 'jane', age: 28 },
+ *     { name: 'joe', age: 26 },
+ *   ],
+ *   x => x.age
+ * ); // Returns: { name: 'joe', age: 26 }
+ */
+export declare function minBy<T>(items: readonly T[], getValue: (element: T) => number): T | undefined;
+//# sourceMappingURL=minBy.d.ts.map

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

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