structured-outputs 0.1.0-beta.2 → 0.1.0-beta.20

package/types/deps/jsr.io/@std/collections/1.0.9/partition.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Returns a tuple of two arrays with the first one containing all elements in
+ * the given array that match the given predicate and the second one containing
+ * all that do not.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to partition.
+ * @param predicate The predicate function to determine which array an element
+ * belongs to.
+ *
+ * @returns A tuple of two arrays. The first array contains all elements that
+ * match the predicate, the second contains all elements that do not.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { partition } from "@std/collections/partition";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [5, 6, 7, 8, 9];
+ * const [even, odd] = partition(numbers, (it) => it % 2 === 0);
+ *
+ * assertEquals(even, [6, 8]);
+ * assertEquals(odd, [5, 7, 9]);
+ * ```
+ */
+export declare function partition<T>(array: Iterable<T>, predicate: (el: T) => boolean): [T[], T[]];
+/**
+ * Returns a tuple of two arrays with the first one containing all elements in
+ * the given array that match the given predicate and the second one containing
+ * all that do not.
+ *
+ * This version of the function is a type-guard version of the function. It
+ * allows you to specify a type-guard predicate function that narrows the type
+ * of the elements in the array.
+ *
+ * @typeParam T The type of the elements in the array.
+ * @typeParam U The type of the elements that match the predicate.
+ *
+ * @param array The array to partition.
+ * @param predicate The type-guard predicate function to determine which array
+ * an element belongs to.
+ *
+ * @returns A tuple of two arrays. The first array contains all elements that
+ * match the predicate, the second contains all elements that do not.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { partition } from "@std/collections/partition";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [5, 6, 7, 8, 9];
+ * const [even, odd] = partition(numbers, (it) => it % 2 === 0);
+ *
+ * assertEquals(even, [6, 8]);
+ * assertEquals(odd, [5, 7, 9]);
+ * ```
+ */
+export declare function partition<T, U extends T>(array: Iterable<T>, predicate: (el: T) => el is U): [U[], Exclude<T, U>[]];
+//# sourceMappingURL=partition.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/partition.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,GAC5B,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACtC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,GAC5B,CAAC,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC"}

package/types/deps/jsr.io/@std/collections/1.0.9/partition_entries.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Returns a tuple of two records with the first one containing all entries of
+ * the given record that match the given predicate and the second one containing
+ * all that do not.
+ *
+ * @typeParam T The type of the values in the record.
+ *
+ * @param record The record to partition.
+ * @param predicate The predicate function to determine which entries go where.
+ *
+ * @returns A tuple containing two records, the first one containing all entries
+ * that match the predicate and the second one containing all that do not.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { partitionEntries } from "@std/collections/partition-entries";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const menu = {
+ *   Salad: 11,
+ *   Soup: 8,
+ *   Pasta: 13,
+ * };
+ * const myOptions = partitionEntries(
+ *   menu,
+ *   ([item, price]) => item !== "Pasta" && price < 10,
+ * );
+ *
+ * assertEquals(
+ *   myOptions,
+ *   [
+ *     { Soup: 8 },
+ *     { Salad: 11, Pasta: 13 },
+ *   ],
+ * );
+ * ```
+ */
+export declare function partitionEntries<T>(record: Readonly<Record<string, T>>, predicate: (entry: [string, T]) => boolean): [match: Record<string, T>, rest: Record<string, T>];
+//# sourceMappingURL=partition_entries.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/partition_entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition_entries.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/partition_entries.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EACnC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,OAAO,GACzC,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAcrD"}

package/types/deps/jsr.io/@std/collections/1.0.9/permutations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Builds all possible orders of all elements in the given array
+ * Ignores equality of elements, meaning this will always return the same
+ * number of permutations for a given length of input.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param inputArray The array to build permutations from.
+ *
+ * @returns An array of all possible permutations of the given array.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { permutations } from "@std/collections/permutations";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [ 1, 2 ];
+ * const windows = permutations(numbers);
+ *
+ * assertEquals(windows, [
+ *   [ 1, 2 ],
+ *   [ 2, 1 ],
+ * ]);
+ * ```
+ */
+export declare function permutations<T>(inputArray: Iterable<T>): T[][];
+//# sourceMappingURL=permutations.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/permutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permutations.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/permutations.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAqC9D"}

package/types/deps/jsr.io/@std/collections/1.0.9/pick.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Creates a new object by including the specified keys from the provided
+ * object.
+ *
+ * @typeParam T The type of the object.
+ * @typeParam K The type of the keys.
+ *
+ * @param obj The object to pick keys from.
+ * @param keys The keys to include in the new object.
+ *
+ * @returns A new object with the specified keys from the provided object.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { pick } from "@std/collections/pick";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = { a: 5, b: 6, c: 7, d: 8 };
+ * const picked = pick(obj, ["a", "c"]);
+ *
+ * assertEquals(picked, { a: 5, c: 7 });
+ * ```
+ */
+export declare function pick<T extends object, K extends keyof T>(obj: Readonly<T>, keys: readonly K[]): Pick<T, K>;
+//# sourceMappingURL=pick.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/pick.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACtD,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,EAChB,IAAI,EAAE,SAAS,CAAC,EAAE,GACjB,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAIZ"}

package/types/deps/jsr.io/@std/collections/1.0.9/reduce_groups.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Applies the given reducer to each group in the given grouping, returning the
+ * results together with the respective group keys.
+ *
+ * @typeParam T input type of an item in a group in the given grouping.
+ * @typeParam A type of the accumulator value, which will match the returned
+ * record's values.
+ *
+ * @param record The grouping to reduce.
+ * @param reducer The reducer function to apply to each group.
+ * @param initialValue The initial value of the accumulator.
+ *
+ * @returns A record with the same keys as the input grouping, where each value
+ * is the result of applying the reducer to the respective group.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { reduceGroups } from "@std/collections/reduce-groups";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const votes = {
+ *   Woody: [2, 3, 1, 4],
+ *   Buzz: [5, 9],
+ * };
+ *
+ * const totalVotes = reduceGroups(votes, (sum, vote) => sum + vote, 0);
+ *
+ * assertEquals(totalVotes, {
+ *   Woody: 10,
+ *   Buzz: 14,
+ * });
+ * ```
+ */
+export declare function reduceGroups<T, A>(record: Readonly<Record<string, ReadonlyArray<T>>>, reducer: (accumulator: A, current: T) => A, initialValue: A): Record<string, A>;
+//# sourceMappingURL=reduce_groups.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/reduce_groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce_groups.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/reduce_groups.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAClD,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAC1C,YAAY,EAAE,CAAC,GACd,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAEnB"}

package/types/deps/jsr.io/@std/collections/1.0.9/running_reduce.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Calls the given reducer on each element of the given collection, passing its
+ * result as the accumulator to the next respective call, starting with the
+ * given initialValue. Returns all intermediate accumulator results.
+ *
+ * @typeParam T The type of the elements in the array.
+ * @typeParam O The type of the accumulator.
+ *
+ * @param array The array to reduce.
+ * @param reducer The reducer function to apply to each element.
+ * @param initialValue The initial value of the accumulator.
+ *
+ * @returns An array of all intermediate accumulator results.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { runningReduce } from "@std/collections/running-reduce";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [1, 2, 3, 4, 5];
+ * const sumSteps = runningReduce(numbers, (sum, current) => sum + current, 0);
+ *
+ * assertEquals(sumSteps, [1, 3, 6, 10, 15]);
+ * ```
+ */
+export declare function runningReduce<T, O>(array: readonly T[], reducer: (accumulator: O, current: T, currentIndex: number) => O, initialValue: O): O[];
+//# sourceMappingURL=running_reduce.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/running_reduce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"running_reduce.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/running_reduce.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAChC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC,EAChE,YAAY,EAAE,CAAC,GACd,CAAC,EAAE,CAKL"}

package/types/deps/jsr.io/@std/collections/1.0.9/sample.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Returns a random element from the given array.
+ *
+ * @typeParam T The type of the elements in the array.
+ * @typeParam O The type of the accumulator.
+ *
+ * @param array The array to sample from.
+ *
+ * @returns A random element from the given array, or `undefined` if the array
+ * is empty.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { sample } from "@std/collections/sample";
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * const numbers = [1, 2, 3, 4];
+ * const random = sample(numbers);
+ *
+ * assertArrayIncludes(numbers, [random]);
+ * ```
+ */
+export declare function sample<T>(array: readonly T[]): T | undefined;
+//# sourceMappingURL=sample.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/sample.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAG5D"}

package/types/deps/jsr.io/@std/collections/1.0.9/sliding_windows.d.ts

@@ -0,0 +1,66 @@
+/** Options for {@linkcode slidingWindows}. */
+export interface SlidingWindowsOptions {
+    /**
+     * If step is set, each window will start that many elements after the last
+     * window's start.
+     *
+     * @default {1}
+     */
+    step?: number;
+    /**
+     * If partial is set, windows will be generated for the last elements of the
+     * collection, resulting in some undefined values if size is greater than 1.
+     *
+     * @default {false}
+     */
+    partial?: boolean;
+}
+/**
+ * Generates sliding views of the given array of the given size and returns a
+ * new array containing all of them.
+ *
+ * If step is set, each window will start that many elements after the last
+ * window's start. (Default: 1)
+ *
+ * If partial is set, windows will be generated for the last elements of the
+ * collection, resulting in some undefined values if size is greater than 1.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to generate sliding windows from.
+ * @param size The size of the sliding windows.
+ * @param options The options for generating sliding windows.
+ *
+ * @returns A new array containing all sliding windows of the given size.
+ *
+ * @example Usage
+ * ```ts
+ * import { slidingWindows } from "@std/collections/sliding-windows";
+ * import { assertEquals } from "@std/assert";
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * const windows = slidingWindows(numbers, 3);
+ * assertEquals(windows, [
+ *   [1, 2, 3],
+ *   [2, 3, 4],
+ *   [3, 4, 5],
+ * ]);
+ *
+ * const windowsWithStep = slidingWindows(numbers, 3, { step: 2 });
+ * assertEquals(windowsWithStep, [
+ *   [1, 2, 3],
+ *   [3, 4, 5],
+ * ]);
+ *
+ * const windowsWithPartial = slidingWindows(numbers, 3, { partial: true });
+ * assertEquals(windowsWithPartial, [
+ *   [1, 2, 3],
+ *   [2, 3, 4],
+ *   [3, 4, 5],
+ *   [4, 5],
+ *   [5],
+ * ]);
+ * ```
+ */
+export declare function slidingWindows<T>(array: readonly T[], size: number, options?: SlidingWindowsOptions): T[][];
+//# sourceMappingURL=sliding_windows.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/sliding_windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliding_windows.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/sliding_windows.ts"],"names":[],"mappings":"AAGA,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,qBAA0B,GAClC,CAAC,EAAE,EAAE,CAaP"}

package/types/deps/jsr.io/@std/collections/1.0.9/sort_by.d.ts

@@ -0,0 +1,161 @@
+/** Order option for {@linkcode SortByOptions}. */
+export type Order = "asc" | "desc";
+/** Options for {@linkcode sortBy}. */
+export type SortByOptions = {
+    /**
+     * The order to sort the elements in.
+     *
+     * @default {"asc"}
+     */
+    order: Order;
+};
+/**
+ * Returns all elements in the given collection, sorted by their result using
+ * the given selector. The selector function is called only once for each
+ * element. Ascending or descending order can be specified through the `order`
+ * option. By default, the elements are sorted in ascending order.
+ *
+ * Note: If you want to process any iterable, use the new version of
+ * `sortBy` from `@std/collections/unstable-sort-by`.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to sort.
+ * @param selector The selector function to get the value to sort by.
+ * @param options The options for sorting.
+ *
+ * @returns A new array containing all elements sorted by the selector.
+ *
+ * @example Usage
+ * ```ts
+ * import { sortBy } from "@std/collections/sort-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ *   { name: "John", age: 23 },
+ * ];
+ * const sortedByAge = sortBy(people, (person) => person.age);
+ *
+ * assertEquals(sortedByAge, [
+ *   { name: "John", age: 23 },
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ * ]);
+ *
+ * const sortedByAgeDesc = sortBy(people, (person) => person.age, { order: "desc" });
+ *
+ * assertEquals(sortedByAgeDesc, [
+ *   { name: "Kim", age: 42 },
+ *   { name: "Anna", age: 34 },
+ *   { name: "John", age: 23 },
+ * ]);
+ * ```
+ */
+export declare function sortBy<T>(array: readonly T[], selector: (el: T) => number, options?: SortByOptions): T[];
+/**
+ * Returns all elements in the given collection, sorted by their result using
+ * the given selector. The selector function is called only once for each
+ * element. Ascending or descending order can be specified through the `order`
+ * option. By default, the elements are sorted in ascending order.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to sort.
+ * @param selector The selector function to get the value to sort by.
+ * @param options The options for sorting.
+ *
+ * @returns A new array containing all elements sorted by the selector.
+ *
+ * @example Usage
+ * ```ts
+ * import { sortBy } from "@std/collections/sort-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna" },
+ *   { name: "Kim" },
+ *   { name: "John" },
+ * ];
+ * const sortedByName = sortBy(people, (it) => it.name);
+ *
+ * assertEquals(sortedByName, [
+ *   { name: "Anna" },
+ *   { name: "John" },
+ *   { name: "Kim" },
+ * ]);
+ * ```
+ */
+export declare function sortBy<T>(array: readonly T[], selector: (el: T) => string, options?: SortByOptions): T[];
+/**
+ * Returns all elements in the given collection, sorted by their result using
+ * the given selector. The selector function is called only once for each
+ * element. Ascending or descending order can be specified through the `order`
+ * option. By default, the elements are sorted in ascending order.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to sort.
+ * @param selector The selector function to get the value to sort by.
+ * @param options The options for sorting.
+ *
+ * @returns A new array containing all elements sorted by the selector.
+ *
+ * @example Usage
+ * ```ts
+ * import { sortBy } from "@std/collections/sort-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34n },
+ *   { name: "Kim", age: 42n },
+ *   { name: "John", age: 23n },
+ * ];
+ *
+ * const sortedByAge = sortBy(people, (person) => person.age);
+ *
+ * assertEquals(sortedByAge, [
+ *   { name: "John", age: 23n },
+ *   { name: "Anna", age: 34n },
+ *   { name: "Kim", age: 42n },
+ * ]);
+ * ```
+ */
+export declare function sortBy<T>(array: readonly T[], selector: (el: T) => bigint, options?: SortByOptions): T[];
+/**
+ * Returns all elements in the given collection, sorted by their result using
+ * the given selector. The selector function is called only once for each
+ * element. Ascending or descending order can be specified through the `order`
+ * option. By default, the elements are sorted in ascending order.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to sort.
+ * @param selector The selector function to get the value to sort by.
+ * @param options The options for sorting.
+ *
+ * @returns A new array containing all elements sorted by the selector.
+ *
+ * @example Usage
+ * ```ts
+ * import { sortBy } from "@std/collections/sort-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", startedAt: new Date("2020-01-01") },
+ *   { name: "Kim", startedAt: new Date("2020-03-01") },
+ *   { name: "John", startedAt: new Date("2020-06-01") },
+ * ];
+ *
+ * const sortedByStartedAt = sortBy(people, (people) => people.startedAt);
+ *
+ * assertEquals(sortedByStartedAt, [
+ *   { name: "Anna", startedAt: new Date("2020-01-01") },
+ *   { name: "Kim", startedAt: new Date("2020-03-01") },
+ *   { name: "John", startedAt: new Date("2020-06-01") },
+ * ]);
+ * ```
+ */
+export declare function sortBy<T>(array: readonly T[], selector: (el: T) => Date, options?: SortByOptions): T[];
+//# sourceMappingURL=sort_by.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/sort_by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort_by.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/sort_by.ts"],"names":[],"mappings":"AAGA,kDAAkD;AAClD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAEnC,sCAAsC;AACtC,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;OAIG;IACH,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,EAC3B,OAAO,CAAC,EAAE,aAAa,GACtB,CAAC,EAAE,CAAC;AACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,EAC3B,OAAO,CAAC,EAAE,aAAa,GACtB,CAAC,EAAE,CAAC;AACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,EAC3B,OAAO,CAAC,EAAE,aAAa,GACtB,CAAC,EAAE,CAAC;AACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,EACzB,OAAO,CAAC,EAAE,aAAa,GACtB,CAAC,EAAE,CAAC"}

package/types/deps/jsr.io/@std/collections/1.0.9/sum_of.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Applies the given selector to all elements in the given collection and
+ * calculates the sum of the results.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to calculate the sum of.
+ * @param selector The selector function to get the value to sum.
+ *
+ * @returns The sum of all elements in the collection.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { sumOf } from "@std/collections/sum-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ *   { name: "John", age: 23 },
+ * ];
+ *
+ * const totalAge = sumOf(people, (person) => person.age);
+ *
+ * assertEquals(totalAge, 99);
+ * ```
+ */
+export declare function sumOf<T>(array: Iterable<T>, selector: (el: T) => number): number;
+//# sourceMappingURL=sum_of.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/sum_of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sum_of.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/sum_of.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,GAC1B,MAAM,CAQR"}

package/types/deps/jsr.io/@std/collections/1.0.9/take_last_while.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Returns all elements in the given array after the last element that does not
+ * match the given predicate.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to take elements from.
+ * @param predicate The predicate function to determine if an element should be
+ * included.
+ *
+ * @returns A new array containing all elements after the last element that does
+ * not match the predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { takeLastWhile } from "@std/collections/take-last-while";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [1, 2, 3, 4, 5, 6];
+ *
+ * const result = takeLastWhile(numbers, (number) => number > 4);
+ *
+ * assertEquals(result, [5, 6]);
+ * ```
+ */
+export declare function takeLastWhile<T>(array: readonly T[], predicate: (el: T) => boolean): T[];
+//# sourceMappingURL=take_last_while.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/take_last_while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take_last_while.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/take_last_while.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,GAC5B,CAAC,EAAE,CAKL"}

package/types/deps/jsr.io/@std/collections/1.0.9/take_while.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Returns all elements in the given collection until the first element that
+ * does not match the given predicate.
+ *
+ * Note: If you want to process any iterable, use the new version of
+ * `takeWhile` from `@std/collections/unstable-take-while`.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to take elements from.
+ * @param predicate The predicate function to determine if an element should be
+ * included.
+ *
+ * @returns A new array containing all elements until the first element that
+ * does not match the predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { takeWhile } from "@std/collections/take-while";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [1, 2, 3, 4, 5, 6];
+ *
+ * const result = takeWhile(numbers, (number) => number < 4);
+ *
+ * assertEquals(result, [1, 2, 3]);
+ * ```
+ */
+export declare function takeWhile<T>(array: readonly T[], predicate: (el: T) => boolean): T[];
+//# sourceMappingURL=take_while.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/take_while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take_while.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/take_while.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,GAC5B,CAAC,EAAE,CASL"}

package/types/deps/jsr.io/@std/collections/1.0.9/union.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Returns all distinct elements that appear in any of the given arrays.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param arrays The arrays to get the union of.
+ *
+ * @returns A new array containing all distinct elements from the given arrays.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { union } from "@std/collections/union";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const soupIngredients = ["Pepper", "Carrots", "Leek"];
+ * const saladIngredients = ["Carrots", "Radicchio", "Pepper"];
+ *
+ * const shoppingList = union(soupIngredients, saladIngredients);
+ *
+ * assertEquals(shoppingList, ["Pepper", "Carrots", "Leek", "Radicchio"]);
+ * ```
+ */
+export declare function union<T>(...arrays: Iterable<T>[]): T[];
+//# sourceMappingURL=union.d.ts.map

package/types/deps/jsr.io/@std/collections/1.0.9/union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/union.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAUtD"}