structured-outputs 0.1.0-beta.10 → 0.1.0-beta.13

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

@@ -0,0 +1,322 @@
+/**
+ * Merges the two given records, recursively merging any nested records with the
+ * second collection overriding the first in case of conflict.
+ *
+ * For arrays, maps and sets, a merging strategy can be specified to either
+ * `replace` values, or `merge` them instead.
+ *
+ * @typeParam T Type of the first record
+ *
+ * @param record First record to merge.
+ * @param other Second record to merge.
+ * @param options Merging options.
+ *
+ * @returns A new record with the merged values.
+ *
+ * @example Merge objects
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: true };
+ * const b = { foo: { bar: true } };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: { bar: true } };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge arrays
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: [1, 2, 3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge maps
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Map([["a", 1]]) };
+ * const b = { foo: new Map([["b", 2]]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Map([["a", 1], ["b", 2]]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge sets
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Set([1]) };
+ * const b = { foo: new Set([2]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Set([1, 2]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge with custom options
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b, { arrays: "replace" });
+ *
+ * const expected = { foo: [3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ */
+export declare function deepMerge<T extends Record<PropertyKey, unknown>>(record: Partial<Readonly<T>>, other: Partial<Readonly<T>>, options?: Readonly<DeepMergeOptions>): T;
+/**
+ * Merges the two given records, recursively merging any nested records with the
+ * second collection overriding the first in case of conflict.
+ *
+ * For arrays, maps and sets, a merging strategy can be specified to either
+ * `replace` values, or `merge` them instead.
+ *
+ * @typeParam T Type of the first record
+ * @typeParam U Type of the second record
+ * @typeParam Options Merging options
+ *
+ * @param record First record to merge.
+ * @param other Second record to merge.
+ * @param options Merging options.
+ *
+ * @returns A new record with the merged values.
+ *
+ * @example Merge objects
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: true };
+ * const b = { foo: { bar: true } };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: { bar: true } };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge arrays
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: [1, 2, 3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge maps
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Map([["a", 1]]) };
+ * const b = { foo: new Map([["b", 2]]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Map([["a", 1], ["b", 2]]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge sets
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Set([1]) };
+ * const b = { foo: new Set([2]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Set([1, 2]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge with custom options
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b, { arrays: "replace" });
+ *
+ * const expected = { foo: [3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ */
+export declare function deepMerge<T extends Record<PropertyKey, unknown>, U extends Record<PropertyKey, unknown>, Options extends DeepMergeOptions>(record: Readonly<T>, other: Readonly<U>, options?: Readonly<Options>): DeepMerge<T, U, Options>;
+/** Merging strategy */
+export type MergingStrategy = "replace" | "merge";
+/** Options for {@linkcode deepMerge}. */
+export type DeepMergeOptions = {
+    /**
+     * Merging strategy for arrays
+     *
+     * @default {"merge"}
+     */
+    arrays?: MergingStrategy;
+    /**
+     * Merging strategy for maps.
+     *
+     * @default {"merge"}
+     */
+    maps?: MergingStrategy;
+    /**
+     * Merging strategy for sets.
+     *
+     * @default {"merge"}
+     */
+    sets?: MergingStrategy;
+};
+/**
+ * How does recursive typing works ?
+ *
+ * Deep merging process is handled through `DeepMerge<T, U, Options>` type.
+ * If both T and U are Records, we recursively merge them,
+ * else we treat them as primitives.
+ *
+ * Merging process is handled through `Merge<T, U>` type, in which
+ * we remove all maps, sets, arrays and records so we can handle them
+ * separately depending on merging strategy:
+ *
+ *    Merge<
+ *      {foo: string},
+ *      {bar: string, baz: Set<unknown>},
+ *    > // "foo" and "bar" will be handled with `MergeRightOmitComplexes`
+ *      // "baz" will be handled with `MergeAll*` type
+ *
+ * `MergeRightOmitComplexes<T, U>` will do the above: all T's
+ * exclusive keys will be kept, though common ones with U will have their
+ * typing overridden instead:
+ *
+ *    MergeRightOmitComplexes<
+ *      {foo: string, baz: number},
+ *      {foo: boolean, bar: string}
+ *    > // {baz: number, foo: boolean, bar: string}
+ *      // "baz" was kept from T
+ *      // "foo" was overridden by U's typing
+ *      // "bar" was added from U
+ *
+ * For Maps, Arrays, Sets and Records, we use `MergeAll*<T, U>` utility
+ * types. They will extract relevant data structure from both T and U
+ * (providing that both have same data data structure, except for typing).
+ *
+ * From these, `*ValueType<T>` will extract values (and keys) types to be
+ * able to create a new data structure with an union typing from both
+ * data structure of T and U:
+ *
+ *    MergeAllSets<
+ *      {foo: Set<number>},
+ *      {foo: Set<string>}
+ *    > // `SetValueType` will extract "number" for T
+ *      // `SetValueType` will extract "string" for U
+ *      // `MergeAllSets` will infer type as Set<number|string>
+ *      // Process is similar for Maps, Arrays, and Sets
+ *
+ * `DeepMerge<T, U, Options>` is taking a third argument to be handle to
+ * infer final typing depending on merging strategy:
+ *
+ *    & (Options extends { sets: "replace" } ? PartialByType<U, Set<unknown>>
+ *      : MergeAllSets<T, U>)
+ *
+ * In the above line, if "Options" have its merging strategy for Sets set to
+ * "replace", instead of performing merging of Sets type, it will take the
+ * typing from right operand (U) instead, effectively replacing the typing.
+ *
+ * An additional note, we use `ExpandRecursively<T>` utility type to expand
+ * the resulting typing and hide all the typing logic of deep merging so it is
+ * more user friendly.
+ */
+/** Force intellisense to expand the typing to hide merging typings */
+export type ExpandRecursively<T> = T extends Record<PropertyKey, unknown> ? T extends infer O ? {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;
+/** Filter of keys matching a given type */
+export type PartialByType<T, U> = {
+    [K in keyof T as T[K] extends U ? K : never]: T[K];
+};
+/** Get set values type */
+export type SetValueType<T> = T extends Set<infer V> ? V : never;
+/** Merge all sets types definitions from keys present in both objects */
+export type MergeAllSets<T, U, X = PartialByType<T, Set<unknown>>, Y = PartialByType<U, Set<unknown>>, Z = {
+    [K in keyof X & keyof Y]: Set<SetValueType<X[K]> | SetValueType<Y[K]>>;
+}> = Z;
+/** Get array values type */
+export type ArrayValueType<T> = T extends Array<infer V> ? V : never;
+/** Merge all sets types definitions from keys present in both objects */
+export type MergeAllArrays<T, U, X = PartialByType<T, Array<unknown>>, Y = PartialByType<U, Array<unknown>>, Z = {
+    [K in keyof X & keyof Y]: Array<ArrayValueType<X[K]> | ArrayValueType<Y[K]>>;
+}> = Z;
+/** Get map values types */
+export type MapKeyType<T> = T extends Map<infer K, unknown> ? K : never;
+/** Get map values types */
+export type MapValueType<T> = T extends Map<unknown, infer V> ? V : never;
+/** Merge all sets types definitions from keys present in both objects */
+export type MergeAllMaps<T, U, X = PartialByType<T, Map<unknown, unknown>>, Y = PartialByType<U, Map<unknown, unknown>>, Z = {
+    [K in keyof X & keyof Y]: Map<MapKeyType<X[K]> | MapKeyType<Y[K]>, MapValueType<X[K]> | MapValueType<Y[K]>>;
+}> = Z;
+/** Merge all records types definitions from keys present in both objects */
+export type MergeAllRecords<T, U, Options, X = PartialByType<T, Record<PropertyKey, unknown>>, Y = PartialByType<U, Record<PropertyKey, unknown>>, Z = {
+    [K in keyof X & keyof Y]: DeepMerge<X[K], Y[K], Options>;
+}> = Z;
+/** Exclude map, sets and array from type */
+export type OmitComplexes<T> = Omit<T, keyof PartialByType<T, Map<unknown, unknown> | Set<unknown> | Array<unknown> | Record<PropertyKey, unknown>>>;
+/** Object with keys in either T or U but not in both */
+export type ObjectXorKeys<T, U, X = Omit<T, keyof U> & Omit<U, keyof T>, Y = {
+    [K in keyof X]: X[K];
+}> = Y;
+/** Merge two objects, with left precedence */
+export type MergeRightOmitComplexes<T, U, X = ObjectXorKeys<T, U> & OmitComplexes<{
+    [K in keyof U]: U[K];
+}>> = X;
+/** Merge two objects */
+export type Merge<T, U, Options, X = MergeRightOmitComplexes<T, U> & MergeAllRecords<T, U, Options> & (Options extends {
+    sets: "replace";
+} ? PartialByType<U, Set<unknown>> : MergeAllSets<T, U>) & (Options extends {
+    arrays: "replace";
+} ? PartialByType<U, Array<unknown>> : MergeAllArrays<T, U>) & (Options extends {
+    maps: "replace";
+} ? PartialByType<U, Map<unknown, unknown>> : MergeAllMaps<T, U>)> = ExpandRecursively<X>;
+/** Merge deeply two objects */
+export type DeepMerge<T, U, Options = Record<string, MergingStrategy>> = [
+    T,
+    U
+] extends [Record<PropertyKey, unknown>, Record<PropertyKey, unknown>] ? Merge<T, U, Options> : T | U;
+//# sourceMappingURL=deep_merge.d.ts.map

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

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

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

@@ -0,0 +1,23 @@
+/**
+ * Returns all distinct elements in the given array, preserving order by first
+ * occurrence.
+ *
+ * @typeParam T The type of the elements in the input array.
+ *
+ * @param array The array to filter for distinct elements.
+ *
+ * @returns An array of distinct elements in the input array.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { distinct } from "@std/collections/distinct";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [3, 2, 5, 2, 5];
+ * const distinctNumbers = distinct(numbers);
+ *
+ * assertEquals(distinctNumbers, [3, 2, 5]);
+ * ```
+ */
+export declare function distinct<T>(array: Iterable<T>): T[];
+//# sourceMappingURL=distinct.d.ts.map

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

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

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

@@ -0,0 +1,26 @@
+/**
+ * Returns all elements in the given array that produce a distinct value using
+ * the given selector, preserving order by first occurrence.
+ *
+ * @typeParam T The type of the elements in the input array.
+ * @typeParam D The type of the values produced by the selector function.
+ *
+ * @param array The array to filter for distinct elements.
+ * @param selector The function to extract the value to compare for
+ * distinctness.
+ *
+ * @returns An array of distinct elements in the input array.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { distinctBy } from "@std/collections/distinct-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const names = ["Anna", "Kim", "Arnold", "Kate"];
+ * const exampleNamesByFirstLetter = distinctBy(names, (name) => name.charAt(0));
+ *
+ * assertEquals(exampleNamesByFirstLetter, ["Anna", "Kim"]);
+ * ```
+ */
+export declare function distinctBy<T, D>(array: Iterable<T>, selector: (el: T) => D): T[];
+//# sourceMappingURL=distinct_by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"distinct_by.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/distinct_by.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,GACrB,CAAC,EAAE,CAWL"}

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

@@ -0,0 +1,26 @@
+/**
+ * Returns a new array that drops all elements in the given collection until the
+ * last element that does not match the given predicate.
+ *
+ * @typeParam T The type of the elements in the input array.
+ *
+ * @param array The array to drop elements from.
+ * @param predicate The function to test each element for a condition.
+ *
+ * @returns A new array that drops all elements until the last element that does
+ * not match the given predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { dropLastWhile } from "@std/collections/drop-last-while";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [11, 42, 55, 20, 33, 44];
+ *
+ * const notFortyFour = dropLastWhile(numbers, (number) => number > 30);
+ *
+ * assertEquals(notFortyFour, [11, 42, 55, 20]);
+ * ```
+ */
+export declare function dropLastWhile<T>(array: readonly T[], predicate: (el: T) => boolean): T[];
+//# sourceMappingURL=drop_last_while.d.ts.map

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

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

@@ -0,0 +1,25 @@
+/**
+ * Returns a new array that drops all elements in the given collection until the
+ * first element that does not match the given predicate.
+ *
+ * @typeParam T The type of the elements in the input array.
+ *
+ * @param array The array to drop elements from.
+ * @param predicate The function to test each element for a condition.
+ *
+ * @returns A new array that drops all elements until the first element that
+ * does not match the given predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { dropWhile } from "@std/collections/drop-while";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [3, 2, 5, 2, 5];
+ * const dropWhileNumbers = dropWhile(numbers, (number) => number !== 2);
+ *
+ * assertEquals(dropWhileNumbers, [2, 5, 2, 5]);
+ * ```
+ */
+export declare function dropWhile<T>(array: readonly T[], predicate: (el: T) => boolean): T[];
+//# sourceMappingURL=drop_while.d.ts.map

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

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

@@ -0,0 +1,32 @@
+/**
+ * Returns a new record with all entries of the given record except the ones
+ * that do not match the given predicate.
+ *
+ * @typeParam T The type of the values in the input record.
+ *
+ * @param record The record to filter entries from.
+ * @param predicate The function to test each entry for a condition.
+ *
+ * @returns A new record with all entries that match the given predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { filterEntries } from "@std/collections/filter-entries";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const menu = {
+ *   Salad: 11,
+ *   Soup: 8,
+ *   Pasta: 13,
+ * };
+ *
+ * const myOptions = filterEntries(
+ *   menu,
+ *   ([item, price]) => item !== "Pasta" && price < 10,
+ * );
+ *
+ * assertEquals(myOptions, { Soup: 8 });
+ * ```
+ */
+export declare function filterEntries<T>(record: Readonly<Record<string, T>>, predicate: (entry: [string, T]) => boolean): Record<string, T>;
+//# sourceMappingURL=filter_entries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter_entries.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/filter_entries.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,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,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAWnB"}

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

@@ -0,0 +1,36 @@
+/**
+ * Returns a new record with all entries of the given record except the ones that
+ * have a key that does not match the given predicate.
+ *
+ * @typeParam T The type of the values in the input record.
+ *
+ * @param record The record to filter keys from.
+ * @param predicate The function to test each key for a condition.
+ *
+ * @returns A new record with all entries that have a key that matches the given
+ * predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { filterKeys } from "@std/collections/filter-keys";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const menu = {
+ *   Salad: 11,
+ *   Soup: 8,
+ *   Pasta: 13,
+ * };
+ *
+ * const menuWithoutSalad = filterKeys(menu, (item) => item !== "Salad");
+ *
+ * assertEquals(
+ *   menuWithoutSalad,
+ *   {
+ *     Soup: 8,
+ *     Pasta: 13,
+ *   },
+ * );
+ * ```
+ */
+export declare function filterKeys<T>(record: Readonly<Record<string, T>>, predicate: (key: string) => boolean): Record<string, T>;
+//# sourceMappingURL=filter_keys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter_keys.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/filter_keys.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EACnC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GAClC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAUnB"}

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

@@ -0,0 +1,35 @@
+/**
+ * Returns a new record with all entries of the given record except the ones
+ * that have a value that does not match the given predicate.
+ *
+ * @typeParam T The type of the values in the input record.
+ *
+ * @param record The record to filter values from.
+ * @param predicate The function to test each value for a condition.
+ *
+ * @returns A new record with all entries that have a value that matches the
+ * given predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { filterValues } from "@std/collections/filter-values";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = {
+ *   Arnold: 37,
+ *   Sarah: 7,
+ *   Kim: 23,
+ * };
+ * const adults = filterValues(people, (person) => person >= 18);
+ *
+ * assertEquals(
+ *   adults,
+ *   {
+ *     Arnold: 37,
+ *     Kim: 23,
+ *   },
+ * );
+ * ```
+ */
+export declare function filterValues<T>(record: Readonly<Record<string, T>>, predicate: (value: T) => boolean): Record<string, T>;
+//# sourceMappingURL=filter_values.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter_values.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/filter_values.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EACnC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAC/B,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAWnB"}

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

@@ -0,0 +1,31 @@
+/**
+ * Returns an element if and only if that element is the only one matching the
+ * given condition. Returns `undefined` otherwise.
+ *
+ * @typeParam T The type of the elements in the input array.
+ *
+ * @param array The array to find a single element in.
+ * @param predicate The function to test each element for a condition.
+ *
+ * @returns The single element that matches the given condition or `undefined`
+ * if there are zero or more than one matching elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { findSingle } from "@std/collections/find-single";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const bookings = [
+ *   { month: "January", active: false },
+ *   { month: "March", active: false },
+ *   { month: "June", active: true },
+ * ];
+ * const activeBooking = findSingle(bookings, (booking) => booking.active);
+ * const inactiveBooking = findSingle(bookings, (booking) => !booking.active);
+ *
+ * assertEquals(activeBooking, { month: "June", active: true });
+ * assertEquals(inactiveBooking, undefined); // There are two applicable items
+ * ```
+ */
+export declare function findSingle<T>(array: Iterable<T>, predicate: (el: T) => boolean): T | undefined;
+//# sourceMappingURL=find_single.d.ts.map

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

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

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

@@ -0,0 +1,32 @@
+/**
+ * Applies the given selector to elements in the given array until a value is
+ * produced that is neither `null` nor `undefined` and returns that value.
+ * Returns `undefined` if no such value is produced.
+ *
+ * @typeParam T The type of the elements in the input array.
+ * @typeParam O The type of the value produced by the selector function.
+ *
+ * @param array The array to select a value from.
+ * @param selector The function to extract a value from an element.
+ *
+ * @returns The first non-`null` and non-`undefined` value produced by the
+ * selector function, or `undefined` if no such value is produced.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { firstNotNullishOf } from "@std/collections/first-not-nullish-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const tables = [
+ *   { number: 11, order: null },
+ *   { number: 12, order: "Soup" },
+ *   { number: 13, order: "Salad" },
+ * ];
+ *
+ * const nextOrder = firstNotNullishOf(tables, (table) => table.order);
+ *
+ * assertEquals(nextOrder, "Soup");
+ * ```
+ */
+export declare function firstNotNullishOf<T, O>(array: Iterable<T>, selector: (item: T) => O | undefined | null): NonNullable<O> | undefined;
+//# sourceMappingURL=first_not_nullish_of.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"first_not_nullish_of.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.0.9/first_not_nullish_of.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EACpC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,GAAG,IAAI,GAC1C,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAU5B"}