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

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

@@ -0,0 +1,90 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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 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 function minOf<T>(
+  array: Iterable<T>,
+  selector: (el: T) => bigint,
+): bigint | undefined;
+export function minOf<T, S extends ((el: T) => number) | ((el: T) => bigint)>(
+  array: Iterable<T>,
+  selector: S,
+): ReturnType<S> | undefined {
+  let minimumValue: ReturnType<S> | undefined;
+
+  for (const element of array) {
+    const currentValue = selector(element) as ReturnType<S>;
+
+    if (minimumValue === undefined || currentValue < minimumValue) {
+      minimumValue = currentValue;
+      continue;
+    }
+
+    if (Number.isNaN(currentValue)) {
+      return currentValue;
+    }
+  }
+
+  return minimumValue;
+}

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

@@ -0,0 +1,42 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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 function minWith<T>(
+  array: Iterable<T>,
+  comparator: (a: T, b: T) => number,
+): T | undefined {
+  let min: T | undefined;
+  let isFirst = true;
+
+  for (const current of array) {
+    if (isFirst || comparator(current, <T> min) < 0) {
+      min = current;
+      isFirst = false;
+    }
+  }
+
+  return min;
+}

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

@@ -0,0 +1,76 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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";

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

@@ -0,0 +1,34 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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 function omit<T extends object, K extends keyof T>(
+  obj: Readonly<T>,
+  keys: readonly K[],
+): Omit<T, K> {
+  const excludes = new Set(keys);
+  return Object.fromEntries(
+    Object.entries(obj).filter(([k, _]) => !excludes.has(k as K)),
+  ) as Omit<T, K>;
+}

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

@@ -0,0 +1,85 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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 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 function partition<T, U extends T>(
+  array: Iterable<T>,
+  predicate: (el: T) => el is U,
+): [U[], Exclude<T, U>[]];
+export function partition(
+  array: Iterable<unknown>,
+  predicate: (el: unknown) => boolean,
+): [unknown[], unknown[]] {
+  const matches: Array<unknown> = [];
+  const rest: Array<unknown> = [];
+
+  for (const element of array) {
+    if (predicate(element)) {
+      matches.push(element);
+    } else {
+      rest.push(element);
+    }
+  }
+
+  return [matches, rest];
+}

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

@@ -0,0 +1,58 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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 function partitionEntries<T>(
+  record: Readonly<Record<string, T>>,
+  predicate: (entry: [string, T]) => boolean,
+): [match: Record<string, T>, rest: Record<string, T>] {
+  const match: Record<string, T> = {};
+  const rest: Record<string, T> = {};
+  const entries = Object.entries(record);
+
+  for (const [key, value] of entries) {
+    if (predicate([key, value])) {
+      match[key] = value;
+    } else {
+      rest[key] = value;
+    }
+  }
+
+  return [match, rest];
+}

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

@@ -0,0 +1,66 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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 function permutations<T>(inputArray: Iterable<T>): T[][] {
+  const result: T[][] = [];
+
+  const array = [...inputArray];
+
+  const k = array.length;
+
+  if (k === 0) {
+    return result;
+  }
+
+  // Heap's Algorithm
+  const c = new Array<number>(k).fill(0);
+
+  result.push([...array]);
+
+  let i = 1;
+
+  while (i < k) {
+    if (c[i]! < i) {
+      if (i % 2 === 0) {
+        [array[0], array[i]] = [array[i], array[0]] as [T, T];
+      } else {
+        [array[c[i]!], array[i]] = [array[i], array[c[i]!]] as [T, T];
+      }
+
+      result.push([...array]);
+
+      c[i]! += 1;
+      i = 1;
+    } else {
+      c[i] = 0;
+      i += 1;
+    }
+  }
+
+  return result;
+}

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

@@ -0,0 +1,34 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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 function pick<T extends object, K extends keyof T>(
+  obj: Readonly<T>,
+  keys: readonly K[],
+): Pick<T, K> {
+  const result = {} as Pick<T, K>;
+  for (const key of keys) if (key in obj) result[key] = obj[key];
+  return result;
+}

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

@@ -0,0 +1,45 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { mapValues } from "./map_values.js";
+
+/**
+ * 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 function reduceGroups<T, A>(
+  record: Readonly<Record<string, ReadonlyArray<T>>>,
+  reducer: (accumulator: A, current: T) => A,
+  initialValue: A,
+): Record<string, A> {
+  return mapValues(record, (value) => value.reduce(reducer, initialValue));
+}

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

@@ -0,0 +1,38 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * 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 function runningReduce<T, O>(
+  array: readonly T[],
+  reducer: (accumulator: O, current: T, currentIndex: number) => O,
+  initialValue: O,
+): O[] {
+  let currentResult = initialValue;
+  return array.map((el, currentIndex) =>
+    currentResult = reducer(currentResult, el, currentIndex)
+  );
+}

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

@@ -0,0 +1,36 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Produces a random number between the inclusive `lower` and `upper` bounds.
+ */
+function randomInteger(lower: number, upper: number): number {
+  return lower + Math.floor(Math.random() * (upper - lower + 1));
+}
+
+/**
+ * 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 function sample<T>(array: readonly T[]): T | undefined {
+  const length = array.length;
+  return length ? array[randomInteger(0, length - 1)] : undefined;
+}

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

@@ -0,0 +1,86 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/** 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 function slidingWindows<T>(
+  array: readonly T[],
+  size: number,
+  options: SlidingWindowsOptions = {},
+): T[][] {
+  const { step = 1, partial = false } = options;
+
+  if (
+    !Number.isInteger(size) || !Number.isInteger(step) || size <= 0 || step <= 0
+  ) {
+    throw new RangeError("Both size and step must be positive integer.");
+  }
+
+  return Array.from(
+    { length: Math.floor((array.length - (partial ? 1 : size)) / step + 1) },
+    (_, i) => array.slice(i * step, i * step + size),
+  );
+}