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

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

@@ -0,0 +1,71 @@
+/**
+ * Applies the given transformer to all values in the given record and returns a
+ * new record containing the resulting keys associated to the last value that
+ * produced them.
+ *
+ * @typeParam T The type of the values in the input record.
+ * @typeParam O The type of the values in the output record.
+ * @typeParam K The type of the keys in the input and output records.
+ *
+ * @param record The record to map values from.
+ * @param transformer The function to transform each value.
+ *
+ * @returns A new record with all values transformed by the given transformer.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { mapValues } from "@std/collections/map-values";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const usersById = {
+ *   a5ec: { name: "Mischa" },
+ *   de4f: { name: "Kim" },
+ * };
+ * const namesById = mapValues(usersById, (user) => user.name);
+ *
+ * assertEquals(
+ *   namesById,
+ *   {
+ *     a5ec: "Mischa",
+ *     de4f: "Kim",
+ *   },
+ * );
+ * ```
+ */
+export declare function mapValues<T, O, K extends string>(record: Readonly<Record<K, T>>, transformer: (value: T, key: K) => O): Record<K, O>;
+/**
+ * Applies the given transformer to all values in the given record and returns a
+ * new record containing the resulting keys associated to the last value that
+ * produced them.
+ *
+ * @typeParam T The type of the values in the input record.
+ * @typeParam O The type of the values in the output record.
+ * @typeParam K The type of the keys in the input and output records.
+ *
+ * @param record The record to map values from.
+ * @param transformer The function to transform each value.
+ *
+ * @returns A new record with all values transformed by the given transformer.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { mapValues } from "@std/collections/map-values";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const usersById = {
+ *   "a5ec": { name: "Mischa" },
+ *   "de4f": { name: "Kim" },
+ * };
+ * const namesById = mapValues(usersById, (user) => user.name);
+ *
+ * assertEquals(
+ *   namesById,
+ *   {
+ *     "a5ec": "Mischa",
+ *     "de4f": "Kim",
+ *   },
+ * );
+ * ```
+ */
+export declare function mapValues<T, O, K extends string>(record: Readonly<Partial<Record<K, T>>>, transformer: (value: T, key: K) => O): Partial<Record<K, O>>;
+//# sourceMappingURL=map_values.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map_values.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/map_values.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,MAAM,EAC9C,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAC9B,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,GACnC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,MAAM,EAC9C,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EACvC,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,GACnC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,117 @@
+/**
+ * Returns the first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxBy } from "@std/collections/max-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ *   { name: "John", age: 23 },
+ * ];
+ *
+ * const personWithMaxAge = maxBy(people, (person) => person.age);
+ *
+ * assertEquals(personWithMaxAge, { name: "Kim", age: 42 });
+ * ```
+ */
+export declare function maxBy<T>(array: Iterable<T>, selector: (el: T) => number): T | undefined;
+/**
+ * Returns the first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxBy } from "@std/collections/max-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna" },
+ *   { name: "Kim" },
+ *   { name: "John" },
+ * ];
+ *
+ * const personWithMaxName = maxBy(people, (person) => person.name);
+ *
+ * assertEquals(personWithMaxName, { name: "Kim" });
+ * ```
+ */
+export declare function maxBy<T>(array: Iterable<T>, selector: (el: T) => string): T | undefined;
+/**
+ * Returns the first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxBy } from "@std/collections/max-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34n },
+ *   { name: "Kim", age: 42n },
+ *   { name: "John", age: 23n },
+ * ];
+ *
+ * const personWithMaxAge = maxBy(people, (person) => person.age);
+ *
+ * assertEquals(personWithMaxAge, { name: "Kim", age: 42n });
+ * ```
+ */
+export declare function maxBy<T>(array: Iterable<T>, selector: (el: T) => bigint): T | undefined;
+/**
+ * Returns the first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxBy } from "@std/collections/max-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", startedAt: new Date("2020-01-01") },
+ *   { name: "Kim", startedAt: new Date("2021-03-01") },
+ *   { name: "John", startedAt: new Date("2020-03-01") },
+ * ];
+ *
+ * const personWithLastStartedAt = maxBy(people, (person) => person.startedAt);
+ *
+ * assertEquals(personWithLastStartedAt, { name: "Kim", startedAt: new Date("2021-03-01") });
+ * ```
+ */
+export declare function maxBy<T>(array: Iterable<T>, selector: (el: T) => Date): T | undefined;
+//# sourceMappingURL=max_by.d.ts.map

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

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

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

@@ -0,0 +1,61 @@
+/**
+ * Applies the given selector to all elements of the provided collection and
+ * returns the max value of all elements. If an empty array is provided the
+ * function will return undefined.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The largest value of the given function or undefined if there are no
+ * elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxOf } from "@std/collections/max-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inventory = [
+ *   { name: "mustard", count: 2 },
+ *   { name: "soy", count: 4 },
+ *   { name: "tomato", count: 32 },
+ * ];
+ *
+ * const maxCount = maxOf(inventory, (item) => item.count);
+ *
+ * assertEquals(maxCount, 32);
+ * ```
+ */
+export declare function maxOf<T>(array: Iterable<T>, selector: (el: T) => number): number | undefined;
+/**
+ * Applies the given selector to all elements of the provided collection and
+ * returns the max value of all elements. If an empty array is provided the
+ * function will return undefined.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxOf } from "@std/collections/max-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inventory = [
+ *   { name: "mustard", count: 2n },
+ *   { name: "soy", count: 4n },
+ *   { name: "tomato", count: 32n },
+ * ];
+ *
+ * const maxCount = maxOf(inventory, (i) => i.count);
+ *
+ * assertEquals(maxCount, 32n);
+ * ```
+ */
+export declare function maxOf<T>(array: Iterable<T>, selector: (el: T) => bigint): bigint | undefined;
+//# sourceMappingURL=max_of.d.ts.map

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

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

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

@@ -0,0 +1,29 @@
+/**
+ * Returns the first element having the largest value according to the provided
+ * comparator or undefined if there are no elements.
+ *
+ * The comparator is expected to work exactly like one passed to `Array.sort`,
+ * which means that `comparator(a, b)` should return a negative number if
+ * `a < b`, a positive number if `a > b` and `0` if `a === b`.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param comparator The function to compare elements.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxWith } from "@std/collections/max-with";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = ["Kim", "Anna", "John", "Arthur"];
+ * const largestName = maxWith(people, (a, b) => a.length - b.length);
+ *
+ * assertEquals(largestName, "Arthur");
+ * ```
+ */
+export declare function maxWith<T>(array: Iterable<T>, comparator: (a: T, b: T) => number): T | undefined;
+//# sourceMappingURL=max_with.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"max_with.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/max_with.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GACjC,CAAC,GAAG,SAAS,CAYf"}

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

@@ -0,0 +1,115 @@
+/**
+ * Returns the first element that is the smallest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minBy } from "@std/collections/min-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ *   { name: "John", age: 23 },
+ * ];
+ *
+ * const personWithMinAge = minBy(people, (i) => i.age);
+ *
+ * assertEquals(personWithMinAge, { name: "John", age: 23 });
+ * ```
+ */
+export declare function minBy<T>(array: Iterable<T>, selector: (el: T) => number): T | undefined;
+/**
+ * Returns the first element that is the smallest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minBy } from "@std/collections/min-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna" },
+ *   { name: "Kim" },
+ *   { name: "John" },
+ * ];
+ *
+ * const personWithMinName = minBy(people, (person) => person.name);
+ *
+ * assertEquals(personWithMinName, { name: "Anna" });
+ * ```
+ */
+export declare function minBy<T>(array: Iterable<T>, selector: (el: T) => string): T | undefined;
+/**
+ * Returns the first element that is the smallest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minBy } from "@std/collections/min-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34n },
+ *   { name: "Kim", age: 42n },
+ *   { name: "John", age: 23n },
+ * ];
+ *
+ * const personWithMinAge = minBy(people, (i) => i.age);
+ *
+ * assertEquals(personWithMinAge, { name: "John", age: 23n });
+ * ```
+ */
+export declare function minBy<T>(array: Iterable<T>, selector: (el: T) => bigint): T | undefined;
+/**
+ * Returns the first element that is the smallest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minBy } from "@std/collections/min-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("2019-01-01") },
+ * ];
+ *
+ * const personWithMinStartedAt = minBy(people, (person) => person.startedAt);
+ * ```
+ */
+export declare function minBy<T>(array: Iterable<T>, selector: (el: T) => Date): T | undefined;
+//# sourceMappingURL=min_by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"min_by.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/min_by.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,GAC1B,CAAC,GAAG,SAAS,CAAC;AACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,GAC1B,CAAC,GAAG,SAAS,CAAC;AACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,MAAM,GAC1B,CAAC,GAAG,SAAS,CAAC;AACjB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,GACxB,CAAC,GAAG,SAAS,CAAC"}

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

@@ -0,0 +1,61 @@
+/**
+ * Applies the given selector to all elements of the given collection and
+ * returns the min value of all elements. If an empty array is provided the
+ * function will return undefined.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The smallest value of the given function or undefined if there are
+ * no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minOf } from "@std/collections/min-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inventory = [
+ *   { name: "mustard", count: 2 },
+ *   { name: "soy", count: 4 },
+ *   { name: "tomato", count: 32 },
+ * ];
+ *
+ * const minCount = minOf(inventory, (item) => item.count);
+ *
+ * assertEquals(minCount, 2);
+ * ```
+ */
+export declare function minOf<T>(array: Iterable<T>, selector: (el: T) => number): number | undefined;
+/**
+ * Applies the given selector to all elements of the given collection and
+ * returns the min value of all elements. If an empty array is provided the
+ * function will return undefined.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minOf } from "@std/collections/min-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inventory = [
+ *   { name: "mustard", count: 2n },
+ *   { name: "soy", count: 4n },
+ *   { name: "tomato", count: 32n },
+ * ];
+ *
+ * const minCount = minOf(inventory, (item) => item.count);
+ *
+ * assertEquals(minCount, 2n);
+ * ```
+ */
+export declare function minOf<T>(array: Iterable<T>, selector: (el: T) => bigint): bigint | undefined;
+//# sourceMappingURL=min_of.d.ts.map

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

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

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

@@ -0,0 +1,25 @@
+/**
+ * Returns the first element having the smallest value according to the provided
+ * comparator or undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param comparator The function to compare elements.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minWith } from "@std/collections/min-with";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = ["Kim", "Anna", "John"];
+ * const smallestName = minWith(people, (a, b) => a.length - b.length);
+ *
+ * assertEquals(smallestName, "Kim");
+ * ```
+ */
+export declare function minWith<T>(array: Iterable<T>, comparator: (a: T, b: T) => number): T | undefined;
+//# sourceMappingURL=min_with.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"min_with.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/min_with.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GACjC,CAAC,GAAG,SAAS,CAYf"}

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

@@ -0,0 +1,73 @@
+/**
+ * Pure functions for common tasks around collection types like arrays and
+ * objects.
+ *
+ * Inspired by
+ * {@link https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/ | Kotlin's Collections}
+ * package and {@link https://lodash.com/ | Lodash}.
+ *
+ * ```ts
+ * import { intersect, sample, pick } from "@std/collections";
+ * import { assertEquals, assertArrayIncludes } from "@std/assert";
+ *
+ * const lisaInterests = ["Cooking", "Music", "Hiking"];
+ * const kimInterests = ["Music", "Tennis", "Cooking"];
+ *
+ * assertEquals(intersect(lisaInterests, kimInterests), ["Cooking", "Music"]);
+ *
+ * assertArrayIncludes(lisaInterests, [sample(lisaInterests)]);
+ *
+ * const cat = { name: "Lulu", age: 3, breed: "Ragdoll" };
+ *
+ * assertEquals(pick(cat, ["name", "breed"]), { name: "Lulu", breed: "Ragdoll"});
+ * ```
+ *
+ * @module
+ */
+export * from "./aggregate_groups.js";
+export * from "./associate_by.js";
+export * from "./associate_with.js";
+export * from "./chunk.js";
+export * from "./deep_merge.js";
+export * from "./distinct.js";
+export * from "./distinct_by.js";
+export * from "./drop_last_while.js";
+export * from "./drop_while.js";
+export * from "./filter_entries.js";
+export * from "./filter_keys.js";
+export * from "./filter_values.js";
+export * from "./find_single.js";
+export * from "./first_not_nullish_of.js";
+export * from "./includes_value.js";
+export * from "./intersect.js";
+export * from "./invert_by.js";
+export * from "./invert.js";
+export * from "./join_to_string.js";
+export * from "./map_entries.js";
+export * from "./map_keys.js";
+export * from "./map_not_nullish.js";
+export * from "./map_values.js";
+export * from "./max_by.js";
+export * from "./max_of.js";
+export * from "./max_with.js";
+export * from "./min_by.js";
+export * from "./min_of.js";
+export * from "./min_with.js";
+export * from "./omit.js";
+export * from "./partition.js";
+export * from "./partition_entries.js";
+export * from "./permutations.js";
+export * from "./pick.js";
+export * from "./reduce_groups.js";
+export * from "./running_reduce.js";
+export * from "./sample.js";
+export * from "./sliding_windows.js";
+export * from "./sort_by.js";
+export * from "./sum_of.js";
+export * from "./take_last_while.js";
+export * from "./take_while.js";
+export * from "./union.js";
+export * from "./unzip.js";
+export * from "./without_all.js";
+export * from "./zip.js";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/omit.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;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,CAKZ"}