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

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

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

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

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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1,36 +0,0 @@
-/**
- * Sorts an array of objects based on the given `criteria` and their corresponding order directions.
- *
- * - If you provide keys, it sorts the objects by the values of those keys.
- * - If you provide functions, it sorts based on the values returned by those functions.
- *
- * The function returns the array of objects sorted in corresponding order directions.
- * If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
- * If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array of objects to be sorted.
- * @param {Array<((item: T) => unknown) | keyof T>} criteria  - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
- * @param {Array<'asc' | 'desc'>} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
- * @returns {T[]} - The sorted array.
- *
- * @example
- * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
- * const users = [
- *   { user: 'fred', age: 48 },
- *   { user: 'barney', age: 34 },
- *   { user: 'fred', age: 40 },
- *   { user: 'barney', age: 36 },
- * ];
- *
- * const result = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']);
- * // result will be:
- * // [
- * //   { user: 'barney', age: 36 },
- * //   { user: 'barney', age: 34 },
- * //   { user: 'fred', age: 48 },
- * //   { user: 'fred', age: 40 },
- * // ]
- */
-export declare function orderBy<T extends object>(arr: readonly T[], criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): T[];
-//# sourceMappingURL=orderBy.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"orderBy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/orderBy.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EACtC,GAAG,EAAE,SAAS,CAAC,EAAE,EACjB,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC,EACjD,MAAM,EAAE,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,GAC5B,CAAC,EAAE,CAqBL"}

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

@@ -1,24 +0,0 @@
-/**
- * Splits an array into two groups based on a predicate function.
- *
- * This function takes an array and a predicate function. It returns a tuple of two arrays:
- * the first array contains elements for which the predicate function returns true, and
- * the second array contains elements for which the predicate function returns false.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to partition.
- * @param {(value: T) => boolean} isInTruthy - A predicate function that determines
- * whether an element should be placed in the truthy array. The function is called with each
- * element of the array.
- * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for
- * which the predicate returned true, and the second array contains elements for which the
- * predicate returned false.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const isEven = x => x % 2 === 0;
- * const [even, odd] = partition(array, isEven);
- * // even will be [2, 4], and odd will be [1, 3, 5]
- */
-export declare function partition<T>(arr: readonly T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]];
-//# sourceMappingURL=partition.d.ts.map

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

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

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

@@ -1,18 +0,0 @@
-/**
- * Removes all specified values from an array.
- *
- * This function changes `arr` in place.
- * If you want to remove values without modifying the original array, use `difference`.
- *
- * @template T, U
- * @param {T[]} arr - The array to modify.
- * @param {unknown[]} valuesToRemove - The values to remove from the array.
- * @returns {T[]} The modified array with the specified values removed.
- *
- * @example
- * const numbers = [1, 2, 3, 4, 5, 2, 4];
- * pull(numbers, [2, 4]);
- * console.log(numbers); // [1, 3, 5]
- */
-export declare function pull<T>(arr: T[], valuesToRemove: readonly unknown[]): T[];
-//# sourceMappingURL=pull.d.ts.map

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

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

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

@@ -1,18 +0,0 @@
-/**
- * Removes elements from an array at specified indices and returns the removed elements.
- *
- * This function supports negative indices, which count from the end of the array.
- *
- * @template T
- * @param {T[]} arr - The array from which elements will be removed.
- * @param {number[]} indicesToRemove - An array of indices specifying the positions of elements to remove.
- * @returns {Array<T | undefined>} An array containing the elements that were removed from the original array.
- *
- * @example
- * const numbers = [10, 20, 30, 40, 50];
- * const removed = pullAt(numbers, [1, 3, 4]);
- * console.log(removed); // [20, 40, 50]
- * console.log(numbers); // [10, 30]
- */
-export declare function pullAt<T>(arr: T[], indicesToRemove: number[]): T[];
-//# sourceMappingURL=pullAt.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pullAt.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/pullAt.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,eAAe,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,CASlE"}

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

@@ -1,18 +0,0 @@
-/**
- * Removes elements from an array based on a predicate function.
- *
- * This function changes `arr` in place.
- * If you want to remove elements without modifying the original array, use `filter`.
- *
- * @template T
- * @param {T[]} arr - The array to modify.
- * @param {(value: T, index: number, array: T[]) => boolean} shouldRemoveElement - The function invoked per iteration to determine if an element should be removed.
- * @returns {T[]} The modified array with the specified elements removed.
- *
- * @example
- * const numbers = [1, 2, 3, 4, 5];
- * remove(numbers, (value) => value % 2 === 0);
- * console.log(numbers); // [1, 3, 5]
- */
-export declare function remove<T>(arr: T[], shouldRemoveElement: (value: T, index: number, array: T[]) => boolean): T[];
-//# sourceMappingURL=remove.d.ts.map

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

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

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

@@ -1,16 +0,0 @@
-/**
- * Returns a random element from an array.
- *
- * This function takes an array and returns a single element selected randomly from the array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to sample from.
- * @returns {T} A random element from the array.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const randomElement = sample(array);
- * // randomElement will be one of the elements from the array, selected randomly.
- */
-export declare function sample<T>(arr: readonly T[]): T;
-//# sourceMappingURL=sample.d.ts.map

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

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

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

@@ -1,20 +0,0 @@
-/**
- * Returns a sample element array of a specified `size`.
- *
- * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.
- *
- * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algorithm}
- *
- * @template T - The type of elements in the array.
- * @param {T[]} array - The array to sample from.
- * @param {number} size - The size of sample.
- * @returns {T[]} A new array with sample size applied.
- * @throws {Error} Throws an error if `size` is greater than the length of `array`.
- *
- * @example
- * const result = sampleSize([1, 2, 3], 2)
- * // result will be an array containing two of the elements from the array.
- * // [1, 2] or [1, 3] or [2, 3]
- */
-export declare function sampleSize<T>(array: readonly T[], size: number): T[];
-//# sourceMappingURL=sampleSize.d.ts.map

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

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

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

@@ -1,16 +0,0 @@
-/**
- * Randomizes the order of elements in an array using the Fisher-Yates algorithm.
- *
- * This function takes an array and returns a new array with its elements shuffled in a random order.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to shuffle.
- * @returns {T[]} A new array with its elements shuffled in random order.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const shuffledArray = shuffle(array);
- * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
- */
-export declare function shuffle<T>(arr: readonly T[]): T[];
-//# sourceMappingURL=shuffle.d.ts.map

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

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

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

@@ -1,34 +0,0 @@
-/**
- * Sorts an array of objects based on the given `criteria`.
- *
- * - If you provide keys, it sorts the objects by the values of those keys.
- * - If you provide functions, it sorts based on the values returned by those functions.
- *
- * The function returns the array of objects sorted in ascending order.
- * If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
- *
- * @template T - The type of the objects in the array.
- * @param {T[]} arr - The array of objects to be sorted.
- * @param {Array<((item: T) => unknown) | keyof T>} criteria - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
- * @returns {T[]} - The sorted array.
- *
- * @example
- * const users = [
- *  { user: 'foo', age: 24 },
- *  { user: 'bar', age: 7 },
- *  { user: 'foo ', age: 8 },
- *  { user: 'bar ', age: 29 },
- * ];
- *
- * sortBy(users, ['user', 'age']);
- * sortBy(users, [obj => obj.user, 'age']);
- * // results will be:
- * // [
- * //   { user : 'bar', age: 7 },
- * //   { user : 'bar', age: 29 },
- * //   { user : 'foo', age: 8 },
- * //   { user : 'foo', age: 24 },
- * // ]
- */
-export declare function sortBy<T extends object>(arr: readonly T[], criteria: Array<((item: T) => unknown) | keyof T>): T[];
-//# sourceMappingURL=sortBy.d.ts.map

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

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

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

@@ -1,66 +0,0 @@
-/**
- * Returns an empty array when the input is a single-element array.
- *
- * @template T - The type of the single element in the array.
- * @param {[T]} arr - The single-element array to process.
- * @returns {[]} An empty array.
- *
- * @example
- * const arr = [1];
- * const result = tail(arr);
- * // result will be []
- */
-export declare function tail<T>(arr: readonly [T]): [];
-/**
- * Returns an empty array when the input is an empty array.
- *
- * @template T - The type of elements in the array.
- * @param {[]} arr - The empty array to process.
- * @returns {[]} An empty array.
- *
- * @example
- * const arr = [];
- * const result = tail(arr);
- * // result will be []
- */
-export declare function tail(arr: readonly []): [];
-/**
- * Returns a new array with all elements except for the first when the input is a tuple array.
- *
- * @template T - The type of the first element in the tuple array.
- * @template U - The type of the remaining elements in the tuple array.
- * @param {[T, ...U[]]} arr - The tuple array to process.
- * @returns {U[]} A new array containing all elements of the input array except for the first one.
- *
- * @example
- * const arr = [1, 2, 3];
- * const result = tail(arr);
- * // result will be [2, 3]
- */
-export declare function tail<T, U>(arr: readonly [T, ...U[]]): U[];
-/**
- * Returns a new array with all elements except for the first.
- *
- * This function takes an array and returns a new array containing all the elements
- * except for the first one. If the input array is empty or has only one element,
- * an empty array is returned.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to get the tail of.
- * @returns {T[]} A new array containing all elements of the input array except for the first one.
- *
- * @example
- * const arr1 = [1, 2, 3];
- * const result = tail(arr1);
- * // result will be [2, 3]
- *
- * const arr2 = [1];
- * const result2 = tail(arr2);
- * // result2 will be []
- *
- * const arr3 = [];
- * const result3 = tail(arr3);
- * // result3 will be []
- */
-export declare function tail<T>(arr: readonly T[]): T[];
-//# sourceMappingURL=tail.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tail.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/tail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAE/C;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,IAAI,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/take.d.ts

@@ -1,24 +0,0 @@
-/**
- * Returns a new array containing the first `count` elements from the input array `arr`.
- * If `count` is greater than the length of `arr`, the entire array is returned.
- *
- * @template T - Type of elements in the input array.
- *
- * @param {T[]} arr - The array to take elements from.
- * @param {number} count - The number of elements to take.
- * @returns {T[]} A new array containing the first `count` elements from `arr`.
- *
- * @example
- * // Returns [1, 2, 3]
- * take([1, 2, 3, 4, 5], 3);
- *
- * @example
- * // Returns ['a', 'b']
- * take(['a', 'b', 'c'], 2);
- *
- * @example
- * // Returns [1, 2, 3]
- * take([1, 2, 3], 5);
- */
-export declare function take<T>(arr: readonly T[], count?: number, guard?: unknown): T[];
-//# sourceMappingURL=take.d.ts.map

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

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

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

@@ -1,23 +0,0 @@
-/**
- * Returns a new array containing the last `count` elements from the input array `arr`.
- * If `count` is greater than the length of `arr`, the entire array is returned.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to take elements from.
- * @param {number} [count=1] - The number of elements to take.
- * @returns {T[]} A new array containing the last `count` elements from `arr`.
- *
- * @example
- * // Returns [4, 5]
- * takeRight([1, 2, 3, 4, 5], 2);
- *
- * @example
- * // Returns ['b', 'c']
- * takeRight(['a', 'b', 'c'], 2);
- *
- * @example
- * // Returns [1, 2, 3]
- * takeRight([1, 2, 3], 5);
- */
-export declare function takeRight<T>(arr: readonly T[], count?: number, guard?: unknown): T[];
-//# sourceMappingURL=takeRight.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"takeRight.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/takeRight.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,SAAI,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,CAAC,EAAE,CAM/E"}

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

@@ -1,19 +0,0 @@
-/**
- * Takes elements from the end of the array while the predicate function returns `true`.
- *
- * @template T - Type of elements in the input array.
- *
- * @param {T[]} arr - The array to take elements from.
- * @param {(item: T) => boolean} shouldContinueTaking - The function invoked per element.
- * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.
- *
- * @example
- * // Returns [3, 2, 1]
- * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);
- *
- * @example
- * // Returns []
- * takeRightWhile([1, 2, 3], n => n > 3);
- */
-export declare function takeRightWhile<T>(arr: readonly T[], shouldContinueTaking: (item: T) => boolean): T[];
-//# sourceMappingURL=takeRightWhile.d.ts.map

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

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

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

@@ -1,20 +0,0 @@
-/**
- * Returns a new array containing the leading elements of the provided array
- * that satisfy the provided predicate function. It stops taking elements as soon
- * as an element does not satisfy the predicate.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to process.
- * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true.
- * @returns {T[]} A new array containing the leading elements that satisfy the predicate.
- *
- * @example
- * // Returns [1, 2]
- * takeWhile([1, 2, 3, 4], x => x < 3);
- *
- * @example
- * // Returns []
- * takeWhile([1, 2, 3, 4], x => x > 3);
- */
-export declare function takeWhile<T>(arr: readonly T[], shouldContinueTaking: (element: T) => boolean): T[];
-//# sourceMappingURL=takeWhile.d.ts.map

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

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

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

@@ -1,91 +0,0 @@
-/**
- * Creates a new array filled with the specified value from the start position up to, but not including, the end position.
- * This function does not mutate the original array.
- *
- * @template T - The type of elements in the original array.
- * @template U - The type of the value to fill the new array with.
- * @param {Array<T>} arr - The array to base the new array on.
- * @param {U} value - The value to fill the new array with.
- * @returns {Array<T | U>} The new array with the filled values.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * let result = toFilled(array, '*', 2);
- * console.log(result); // [1, 2, '*', '*', '*']
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*', 1, 4);
- * console.log(result); // [1, '*', '*', '*', 5]
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*');
- * console.log(result); // ['*', '*', '*', '*', '*']
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*', -4, -1);
- * console.log(result); // [1, '*', '*', '*', 5]
- * console.log(array); // [1, 2, 3, 4, 5]
- */
-export declare function toFilled<T, U>(arr: readonly T[], value: U): Array<T | U>;
-/**
- * Creates a new array filled with the specified value from the start position up to, but not including, the end position.
- * This function does not mutate the original array.
- *
- * @template T - The type of elements in the original array.
- * @template U - The type of the value to fill the new array with.
- * @param {Array<T>} arr - The array to base the new array on.
- * @param {U} value - The value to fill the new array with.
- * @param {number} [start=0] - The start position. Defaults to 0.
- * @returns {Array<T | U>} The new array with the filled values.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * let result = toFilled(array, '*', 2);
- * console.log(result); // [1, 2, '*', '*', '*']
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*', 1, 4);
- * console.log(result); // [1, '*', '*', '*', 5]
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*');
- * console.log(result); // ['*', '*', '*', '*', '*']
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*', -4, -1);
- * console.log(result); // [1, '*', '*', '*', 5]
- * console.log(array); // [1, 2, 3, 4, 5]
- */
-export declare function toFilled<T, U>(arr: readonly T[], value: U, start: number): Array<T | U>;
-/**
- * Creates a new array filled with the specified value from the start position up to, but not including, the end position.
- * This function does not mutate the original array.
- *
- * @template T - The type of elements in the original array.
- * @template U - The type of the value to fill the new array with.
- * @param {Array<T>} arr - The array to base the new array on.
- * @param {U} value - The value to fill the new 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 new array with the filled values.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * let result = toFilled(array, '*', 2);
- * console.log(result); // [1, 2, '*', '*', '*']
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*', 1, 4);
- * console.log(result); // [1, '*', '*', '*', 5]
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*');
- * console.log(result); // ['*', '*', '*', '*', '*']
- * console.log(array); // [1, 2, 3, 4, 5]
- *
- * result = toFilled(array, '*', -4, -1);
- * console.log(result); // [1, '*', '*', '*', 5]
- * console.log(array); // [1, 2, 3, 4, 5]
- */
-export declare function toFilled<T, U>(arr: readonly T[], value: U, start: number, end: number): Array<T | U>;
-//# sourceMappingURL=toFilled.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"toFilled.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/toFilled.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC"}

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

@@ -1,19 +0,0 @@
-/**
- * Creates an array of unique values from all given arrays.
- *
- * This function takes two arrays, merges them into a single array, and returns a new array
- * containing only the unique values from the merged array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr1 - The first array to merge and filter for unique values.
- * @param {T[]} arr2 - The second array to merge and filter for unique values.
- * @returns {T[]} A new array of unique values.
- *
- * @example
- * const array1 = [1, 2, 3];
- * const array2 = [3, 4, 5];
- * const result = union(array1, array2);
- * // result will be [1, 2, 3, 4, 5]
- */
-export declare function union<T>(arr1: readonly T[], arr2: readonly T[]): T[];
-//# sourceMappingURL=union.d.ts.map