@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/uniqBy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Returns a new array containing only the unique elements from the original array,
+ * based on the values returned by the mapper function.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of mapped elements.
+ * @param {T[]} arr - The array to process.
+ * @param {(item: T) => U} mapper - The function used to convert the array elements.
+ * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the mapper function.
+ *
+ * @example
+ * ```ts
+ * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
+ * // [1.2, 2.1, 3.2, 5.7, 7.19]
+ * ```
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' },
+ * ];
+ * uniqBy(array, item => item.category).length
+ * // 2
+ * ```
+ */
+export declare function uniqBy<T, U>(arr: readonly T[], mapper: (item: T) => U): T[];
+//# sourceMappingURL=uniqBy.d.ts.map

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * Returns a new array containing only the unique elements from the original array,
+ * based on the values returned by the comparator function.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to process.
+ * @param {(item1: T, item2: T) => boolean} areItemsEqual - The function used to compare the array elements.
+ * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the comparator function.
+ *
+ * @example
+ * ```ts
+ * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);
+ * // [1.2, 3.2, 5.7, 7.19]
+ * ```
+ */
+export declare function uniqWith<T>(arr: readonly T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+//# sourceMappingURL=uniqWith.d.ts.map

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * Gathers elements in the same position in an internal array
+ * from a grouped array of elements and returns them as a new array.
+ *
+ * @template T - The type of elements in the nested array.
+ * @param {Array<[...T]>} zipped - The nested array to unzip.
+ * @returns {Unzip<T>} A new array of unzipped elements.
+ *
+ * @example
+ * const zipped = [['a', true, 1],['b', false, 2]];
+ * const result = unzip(zipped);
+ * // result will be [['a', 'b'], [true, false], [1, 2]]
+ */
+export declare function unzip<T extends unknown[]>(zipped: ReadonlyArray<[...T]>): Unzip<T>;
+type Unzip<K extends unknown[]> = {
+    [I in keyof K]: Array<K[I]>;
+};
+export {};
+//# sourceMappingURL=unzip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unzip.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/unzip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAqBlF;AAED,KAAK,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC"}

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

@@ -0,0 +1,16 @@
+/**
+ * Unzips an array of arrays, applying an `iteratee` function to regrouped elements.
+ *
+ * @template T, R
+ * @param {T[][]} target - The nested array to unzip. This is an array of arrays,
+ * where each inner array contains elements to be unzipped.
+ * @param {(...args: T[]) => R} iteratee - A function to transform the unzipped elements.
+ * @returns {R[]} A new array of unzipped and transformed elements.
+ *
+ * @example
+ * const nestedArray = [[1, 2], [3, 4], [5, 6]];
+ * const result = unzipWith(nestedArray, (item, item2, item3) => item + item2 + item3);
+ * // result will be [9, 12]
+ */
+export declare function unzipWith<T, R>(target: readonly T[][], iteratee: (...args: T[]) => R): R[];
+//# sourceMappingURL=unzipWith.d.ts.map

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

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

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

@@ -0,0 +1,49 @@
+/**
+ * Options for the windowed function.
+ *
+ * @interface WindowedOptions
+ * @property {boolean} [partialWindows=false] - Whether to include partial windows at the end of the array.
+ */
+export interface WindowedOptions {
+    /**
+     * Whether to include partial windows at the end of the array.
+     *
+     * By default, `windowed` only includes full windows in the result,
+     * ignoring any leftover elements that can't form a full window.
+     *
+     * If `partialWindows` is true, the function will also include these smaller, partial windows at the end of the result.
+     */
+    partialWindows?: boolean;
+}
+/**
+ * Creates an array of sub-arrays (windows) from the input array, each of the specified size.
+ * The windows can overlap depending on the step size provided.
+ *
+ * By default, only full windows are included in the result, and any leftover elements that can't form a full window are ignored.
+ *
+ * If the `partialWindows` option is set to true in the options object, the function will also include partial windows at the end of the result.
+ * Partial windows are smaller sub-arrays created when there aren't enough elements left in the input array to form a full window.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The input array to create windows from.
+ * @param {number} size - The size of each window. Must be a positive integer.
+ * @param {number} [step=1] - The step size between the start of each window. Must be a positive integer.
+ * @param {WindowedOptions} [options={}] - Options object to configure the behavior of the function.
+ * @param {boolean} [options.partialWindows=false] - Whether to include partial windows at the end of the array.
+ * @returns {T[][]} An array of windows (sub-arrays) created from the input array.
+ * @throws {Error} If the size or step is not a positive integer.
+ *
+ * @example
+ * windowed([1, 2, 3, 4], 2);
+ * // => [[1, 2], [2, 3], [3, 4]]
+ *
+ * @example
+ * windowed([1, 2, 3, 4, 5, 6], 3, 2);
+ * // => [[1, 2, 3], [3, 4, 5]]
+ *
+ * @example
+ * windowed([1, 2, 3, 4, 5, 6], 3, 2, { partialWindows: true });
+ * // => [[1, 2, 3], [3, 4, 5], [5, 6]]
+ */
+export declare function windowed<T>(arr: readonly T[], size: number, step?: number, { partialWindows }?: WindowedOptions): T[][];
+//# sourceMappingURL=windowed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"windowed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/windowed.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,GAAG,EAAE,SAAS,CAAC,EAAE,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,SAAI,EACR,EAAE,cAAsB,EAAE,GAAE,eAAoB,GAC/C,CAAC,EAAE,EAAE,CAiBP"}

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

@@ -0,0 +1,22 @@
+/**
+ * Creates an array that excludes all specified values.
+ *
+ * It correctly excludes `NaN`, as it compares values using [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero).
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array - The array to filter.
+ * @param {...T[]} values - The values to exclude.
+ * @returns {T[]} A new array without the specified values.
+ *
+ * @example
+ * // Removes the specified values from the array
+ * without([1, 2, 3, 4, 5], 2, 4);
+ * // Returns: [1, 3, 5]
+ *
+ * @example
+ * // Removes specified string values from the array
+ * without(['a', 'b', 'c', 'a'], 'a');
+ * // Returns: ['b', 'c']
+ */
+export declare function without<T>(array: readonly T[], ...values: T[]): T[];
+//# sourceMappingURL=without.d.ts.map

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements
+ * which are in either of the arrays, but not in their intersection.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both.
+ *
+ * @example
+ * // Returns [1, 2, 5, 6]
+ * xor([1, 2, 3, 4], [3, 4, 5, 6]);
+ *
+ * @example
+ * // Returns ['a', 'c']
+ * xor(['a', 'b'], ['b', 'c']);
+ */
+export declare function xor<T>(arr1: readonly T[], arr2: readonly T[]): T[];
+//# sourceMappingURL=xor.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Computes the symmetric difference between two arrays using a custom mapping function.
+ * The symmetric difference is the set of elements which are in either of the arrays,
+ * but not in their intersection, determined by the result of the mapping function.
+ *
+ * @template T - Type of elements in the input arrays.
+ * @template U - Type of the values returned by the mapping function.
+ *
+ * @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[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.
+ *
+ * @example
+ * // Custom mapping function for objects with an 'id' property
+ * const idMapper = obj => obj.id;
+ * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+export declare function xorBy<T, U>(arr1: readonly T[], arr2: readonly T[], mapper: (item: T) => U): T[];
+//# sourceMappingURL=xorBy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"xorBy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/xorBy.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,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,CAK/F"}

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

@@ -0,0 +1,20 @@
+/**
+ * Computes the symmetric difference between two arrays using a custom equality function.
+ * The symmetric difference is the set of elements which are in either of the arrays,
+ * but not in their intersection.
+ *
+ * @template T - Type of elements in the input arrays.
+ *
+ * @param {T[]} arr1 - The first array.
+ * @param {T[]} arr2 - The second array.
+ * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements.
+ * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function.
+ *
+ * @example
+ * // Custom equality function for objects with an 'id' property
+ * const areObjectsEqual = (a, b) => a.id === b.id;
+ * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual);
+ * // Returns [{ id: 1 }, { id: 3 }]
+ */
+export declare function xorWith<T>(arr1: readonly T[], arr2: readonly T[], areElementsEqual: (item1: T, item2: T) => boolean): T[];
+//# sourceMappingURL=xorWith.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"xorWith.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/xorWith.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,gBAAgB,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,GAChD,CAAC,EAAE,CAKL"}

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

@@ -0,0 +1,105 @@
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T
+ * @param {T[]} arr1 - The first array to zip.
+ * @returns {Array<[T]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const result = zip(arr1);
+ * // result will be [[1], [2], [3]]
+ */
+export declare function zip<T>(arr1: readonly T[]): Array<[T]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {U[]} arr2 - The second array to zip.
+ * @returns {Array<[T, U]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const result = zip(arr1, arr2);
+ * // result will be [[1, 'a'], [2, 'b'], [3, 'c']]
+ */
+export declare function zip<T, U>(arr1: readonly T[], arr2: readonly U[]): Array<[T, U]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U, V
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {U[]} arr2 - The second array to zip.
+ * @param {V[]} arr3 - The third array to zip.
+ * @returns {Array<[T, U, V]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const result = zip(arr1, arr2, arr3);
+ * // result will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
+ */
+export declare function zip<T, U, V>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[]): Array<[T, U, V]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T, U, V, W
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {U[]} arr2 - The second array to zip.
+ * @param {V[]} arr3 - The third array to zip.
+ * @param {W[]} arr4 - The fourth array to zip.
+ * @returns {Array<[T, U, V, W]>} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const arr4 = [null, null, null];
+ * const result = zip(arr1, arr2, arr3, arr4);
+ * // result will be [[1, 'a', true, null], [2, 'b', false, null], [3, 'c', undefined, null]]
+ */
+export declare function zip<T, U, V, W>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): Array<[T, U, V, W]>;
+/**
+ * Combines multiple arrays into a single array of tuples.
+ *
+ * This function takes multiple arrays and returns a new array where each element is a tuple
+ * containing the corresponding elements from the input arrays. If the input arrays are of
+ * different lengths, the resulting array will have the length of the longest input array,
+ * with undefined values for missing elements.
+ *
+ * @template T
+ * @param {...Array<readonly T[]>} arrs - The arrays to zip together.
+ * @returns {T[][]} A new array of tuples containing the corresponding elements from the input arrays.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const arr2 = ['a', 'b', 'c'];
+ * const arr3 = [true, false];
+ * const result = zip(arr1, arr2, arr3);
+ * // result will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
+ */
+export declare function zip<T>(...arrs: Array<readonly T[]>): T[][];
+//# sourceMappingURL=zip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/zip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE3G;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAC5B,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,GACjB,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEvB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC"}

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

@@ -0,0 +1,32 @@
+/**
+ * Combines two arrays, one of property names and one of corresponding values, into a single object.
+ *
+ * This function takes two arrays: one containing property names and another containing corresponding values.
+ * It returns a new object where the property names from the first array are keys, and the corresponding elements
+ * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will
+ * have `undefined` as their values.
+ *
+ * @template P - The type of elements in the array.
+ * @template V - The type of elements in the array.
+ * @param {P[]} keys - An array of property names.
+ * @param {V[]} values - An array of values corresponding to the property names.
+ * @returns {Record<P, V>} - A new object composed of the given property names and values.
+ *
+ * @example
+ * const keys = ['a', 'b', 'c'];
+ * const values = [1, 2, 3];
+ * const result = zipObject(keys, values);
+ * // result will be { a: 1, b: 2, c: 3 }
+ *
+ * const keys2 = ['a', 'b', 'c'];
+ * const values2 = [1, 2];
+ * const result2 = zipObject(keys2, values2);
+ * // result2 will be { a: 1, b: 2, c: undefined }
+ *
+ * const keys2 = ['a', 'b'];
+ * const values2 = [1, 2, 3];
+ * const result2 = zipObject(keys2, values2);
+ * // result2 will be { a: 1, b: 2 }
+ */
+export declare function zipObject<P extends PropertyKey, V>(keys: readonly P[], values: readonly V[]): Record<P, V>;
+//# sourceMappingURL=zipObject.d.ts.map

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

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

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

@@ -0,0 +1,71 @@
+/**
+ * Combines multiple arrays into a single array using a custom combiner function.
+ *
+ * This function takes multiple arrays and a combiner function, and returns a new array where each element
+ * is the result of applying the combiner function to the corresponding elements of the input arrays.
+ *
+ * @template T - The type of elements in the first array.
+ * @template R - The type of elements in the resulting array.
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {(...items: T[]) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
+ * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
+ *
+ * @example
+ * // Example usage with two arrays:
+ * const arr1 = [1, 2, 3];
+ * const arr2 = [4, 5, 6];
+ * const result = zipWith(arr1, arr2, (a, b) => a + b);
+ * // result will be [5, 7, 9]
+ *
+ * @example
+ * // Example usage with three arrays:
+ * const arr1 = [1, 2];
+ * const arr2 = [3, 4];
+ * const arr3 = [5, 6];
+ * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`);
+ * // result will be [`135`, `246`]
+ */
+export declare function zipWith<T, R>(arr1: readonly T[], combine: (item: T) => R): R[];
+/**
+ * Combines two arrays into a single array using a custom combiner function.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @template R - The type of elements in the resulting array.
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {U[]} arr2 - The second array to zip.
+ * @param {(item1: T, item2: U) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
+ * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
+ */
+export declare function zipWith<T, U, R>(arr1: readonly T[], arr2: readonly U[], combine: (item1: T, item2: U) => R): R[];
+/**
+ * Combines three arrays into a single array using a custom combiner function.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template R - The type of elements in the resulting array.
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {U[]} arr2 - The second array to zip.
+ * @param {V[]} arr3 - The third array to zip.
+ * @param {(item1: T, item2: U, item3: V) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
+ * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
+ */
+export declare function zipWith<T, U, V, R>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[], combine: (item1: T, item2: U, item3: V) => R): R[];
+/**
+ * Combines four arrays into a single array using a custom combiner function.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @template V - The type of elements in the third array.
+ * @template W - The type of elements in the fourth array.
+ * @template R - The type of elements in the resulting array.
+ * @param {T[]} arr1 - The first array to zip.
+ * @param {U[]} arr2 - The second array to zip.
+ * @param {V[]} arr3 - The third array to zip.
+ * @param {W[]} arr4 - The fourth array to zip.
+ * @param {(item1: T, item2: U, item3: V, item4: W) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
+ * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
+ */
+export declare function zipWith<T, U, V, W, R>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[], arr4: readonly W[], combine: (item1: T, item2: U, item3: V, item4: W) => R): R[];
+//# sourceMappingURL=zipWith.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zipWith.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/zipWith.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;AAChF;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;AAClH;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAChC,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAC3C,CAAC,EAAE,CAAC;AACP;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACnC,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GACrD,CAAC,EAAE,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/getSymbols.d.ts

@@ -0,0 +1,2 @@
+export declare function getSymbols(object: any): symbol[];
+//# sourceMappingURL=getSymbols.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/getSymbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSymbols.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/getSymbols.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,MAAM,EAAE,GAAG,YAIrC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/getTag.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {T} value The value to query.
+ * @returns {string} Returns the `Object.prototype.toString.call` result.
+ */
+export declare function getTag<T>(value: T): string;
+//# sourceMappingURL=getTag.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/getTag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTag.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/getTag.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,UAKjC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/tags.d.ts

@@ -0,0 +1,27 @@
+export declare const regexpTag = "[object RegExp]";
+export declare const stringTag = "[object String]";
+export declare const numberTag = "[object Number]";
+export declare const booleanTag = "[object Boolean]";
+export declare const argumentsTag = "[object Arguments]";
+export declare const symbolTag = "[object Symbol]";
+export declare const dateTag = "[object Date]";
+export declare const mapTag = "[object Map]";
+export declare const setTag = "[object Set]";
+export declare const arrayTag = "[object Array]";
+export declare const functionTag = "[object Function]";
+export declare const arrayBufferTag = "[object ArrayBuffer]";
+export declare const objectTag = "[object Object]";
+export declare const errorTag = "[object Error]";
+export declare const dataViewTag = "[object DataView]";
+export declare const uint8ArrayTag = "[object Uint8Array]";
+export declare const uint8ClampedArrayTag = "[object Uint8ClampedArray]";
+export declare const uint16ArrayTag = "[object Uint16Array]";
+export declare const uint32ArrayTag = "[object Uint32Array]";
+export declare const bigUint64ArrayTag = "[object BigUint64Array]";
+export declare const int8ArrayTag = "[object Int8Array]";
+export declare const int16ArrayTag = "[object Int16Array]";
+export declare const int32ArrayTag = "[object Int32Array]";
+export declare const bigInt64ArrayTag = "[object BigInt64Array]";
+export declare const float32ArrayTag = "[object Float32Array]";
+export declare const float64ArrayTag = "[object Float64Array]";
+//# sourceMappingURL=tags.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/_internal/tags.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,oBAAoB,CAAC;AAC3C,eAAO,MAAM,SAAS,oBAAoB,CAAC;AAC3C,eAAO,MAAM,SAAS,oBAAoB,CAAC;AAC3C,eAAO,MAAM,UAAU,qBAAqB,CAAC;AAC7C,eAAO,MAAM,YAAY,uBAAuB,CAAC;AACjD,eAAO,MAAM,SAAS,oBAAoB,CAAC;AAC3C,eAAO,MAAM,OAAO,kBAAkB,CAAC;AACvC,eAAO,MAAM,MAAM,iBAAiB,CAAC;AACrC,eAAO,MAAM,MAAM,iBAAiB,CAAC;AACrC,eAAO,MAAM,QAAQ,mBAAmB,CAAC;AACzC,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAC/C,eAAO,MAAM,cAAc,yBAAyB,CAAC;AACrD,eAAO,MAAM,SAAS,oBAAoB,CAAC;AAC3C,eAAO,MAAM,QAAQ,mBAAmB,CAAC;AACzC,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAC/C,eAAO,MAAM,aAAa,wBAAwB,CAAC;AACnD,eAAO,MAAM,oBAAoB,+BAA+B,CAAC;AACjE,eAAO,MAAM,cAAc,yBAAyB,CAAC;AACrD,eAAO,MAAM,cAAc,yBAAyB,CAAC;AACrD,eAAO,MAAM,iBAAiB,4BAA4B,CAAC;AAC3D,eAAO,MAAM,YAAY,uBAAuB,CAAC;AACjD,eAAO,MAAM,aAAa,wBAAwB,CAAC;AACnD,eAAO,MAAM,aAAa,wBAAwB,CAAC;AACnD,eAAO,MAAM,gBAAgB,2BAA2B,CAAC;AACzD,eAAO,MAAM,eAAe,0BAA0B,CAAC;AACvD,eAAO,MAAM,eAAe,0BAA0B,CAAC"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isArray.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Checks if the given value is an array.
+ *
+ * This function tests whether the provided value is an array or not.
+ * It returns `true` if the value is an array, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an array.
+ *
+ * @param {unknown} value - The value to test if it is an array.
+ * @returns {value is any[]} `true` if the value is an array, `false` otherwise.
+ *
+ * @example
+ * const value1 = [1, 2, 3];
+ * const value2 = 'abc';
+ * const value3 = () => {};
+ *
+ * console.log(isArray(value1)); // true
+ * console.log(isArray(value2)); // false
+ * console.log(isArray(value3)); // false
+ */
+export declare function isArray(value?: unknown): value is any[];
+//# sourceMappingURL=isArray.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isArray.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isArray.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,EAAE,CAEvD"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isObjectLike.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Checks if the given value is object-like.
+ *
+ * A value is object-like if its type is object and it is not null.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object-like value.
+ *
+ * @template T - The type of value.
+ * @param {T} value - The value to test if it is an object-like.
+ * @returns {value is object} `true` if the value is an object-like, `false` otherwise.
+ *
+ * @example
+ * const value1 = { a: 1 };
+ * const value2 = [1, 2, 3];
+ * const value3 = 'abc';
+ * const value4 = () => {};
+ * const value5 = null;
+ *
+ * console.log(isObjectLike(value1)); // true
+ * console.log(isObjectLike(value2)); // true
+ * console.log(isObjectLike(value3)); // false
+ * console.log(isObjectLike(value4)); // false
+ * console.log(isObjectLike(value5)); // false
+ */
+export declare function isObjectLike(value?: unknown): value is object;
+//# sourceMappingURL=isObjectLike.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isObjectLike.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObjectLike.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isObjectLike.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D"}

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isPlainObject.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Checks if a given value is a plain object.
+ *
+ * A plain object is an object created by the `{}` literal, `new Object()`, or
+ * `Object.create(null)`.
+ *
+ * This function also handles objects with custom
+ * `Symbol.toStringTag` properties.
+ *
+ * `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the
+ * default string description of objects.
+ *
+ * @param {unknown} [object] - The value to check.
+ * @returns {boolean} - True if the value is a plain object, otherwise false.
+ *
+ * @example
+ * console.log(isPlainObject({})); // true
+ * console.log(isPlainObject([])); // false
+ * console.log(isPlainObject(null)); // false
+ * console.log(isPlainObject(Object.create(null))); // true
+ * console.log(isPlainObject(new Map())); // false
+ */
+export declare function isPlainObject(object?: unknown): object is Record<PropertyKey, any>;
+//# sourceMappingURL=isPlainObject.d.ts.map

package/types/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isPlainObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/compat/predicate/isPlainObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,IAAI,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,CAsClF"}