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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,24 @@
+/**
+ * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of mapped elements.
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @param {(item: T) => U} mapper - The function to map array elements to comparison values.
+ * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function.
+ *
+ * @example
+ * // Custom mapping function for numbers (modulo comparison)
+ * const moduloMapper = (x) => x % 3;
+ * unionBy([1, 2, 3], [4, 5, 6], moduloMapper);
+ * // Returns [1, 2, 3]
+ *
+ * @example
+ * // Custom mapping function for objects with an 'id' property
+ * const idMapper = (obj) => obj.id;
+ * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
+ * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]
+ */
+export declare function unionBy<T, U>(arr1: readonly T[], arr2: readonly T[], mapper: (item: T) => U): T[];
+//# sourceMappingURL=unionBy.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+/**
+ * Creates an array of unique values from two given arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom equality function, merges the arrays, and returns
+ * a new array containing only the unique values as determined by the custom equality function.
+ *
+ * @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.
+ * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
+ * It takes two arguments and returns `true` if the elements are considered equal, and `false` otherwise.
+ * @returns {T[]} A new array of unique values based on the custom equality function.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }];
+ * const array2 = [{ id: 2 }, { id: 3 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = unionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
+ */
+export declare function unionWith<T>(arr1: readonly T[], arr2: readonly T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+//# sourceMappingURL=unionWith.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unionWith.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/unionWith.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,aAAa,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,GAC7C,CAAC,EAAE,CAEL"}

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

@@ -0,0 +1,17 @@
+/**
+ * Creates a duplicate-free version of an array.
+ *
+ * This function takes an array and returns a new array containing only the unique values
+ * from the original array, preserving the order of first occurrence.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to process.
+ * @returns {T[]} A new array with only unique values from the original array.
+ *
+ * @example
+ * const array = [1, 2, 2, 3, 4, 4, 5];
+ * const result = uniq(array);
+ * // result will be [1, 2, 3, 4, 5]
+ */
+export declare function uniq<T>(arr: readonly T[]): T[];
+//# sourceMappingURL=uniq.d.ts.map

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

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