structured-outputs 0.1.0-beta.11 → 0.1.0-beta.14

package/src/deps/jsr.io/@std/assert/1.0.8/equal.ts

@@ -0,0 +1,210 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import * as dntShim from "../../../../../_dnt.shims.js";
+
+
+type KeyedCollection = Set<unknown> | Map<unknown, unknown>;
+function isKeyedCollection(x: unknown): x is KeyedCollection {
+  return x instanceof Set || x instanceof Map;
+}
+
+function prototypesEqual(a: object, b: object) {
+  const pa = Object.getPrototypeOf(a);
+  const pb = Object.getPrototypeOf(b);
+  return pa === pb ||
+    pa === Object.prototype && pb === null ||
+    pa === null && pb === Object.prototype;
+}
+
+function isBasicObjectOrArray(obj: object) {
+  const proto = Object.getPrototypeOf(obj);
+  return proto === null || proto === Object.prototype ||
+    proto === Array.prototype;
+}
+
+// Slightly faster than Reflect.ownKeys in V8 as of 12.9.202.13-rusty (2024-10-28)
+function ownKeys(obj: object) {
+  return [
+    ...Object.getOwnPropertyNames(obj),
+    ...Object.getOwnPropertySymbols(obj),
+  ];
+}
+
+function getKeysDeep(obj: object) {
+  const keys = new Set<string | symbol>();
+
+  while (obj !== Object.prototype && obj !== Array.prototype && obj != null) {
+    for (const key of ownKeys(obj)) {
+      keys.add(key);
+    }
+    obj = Object.getPrototypeOf(obj);
+  }
+
+  return keys;
+}
+
+// deno-lint-ignore no-explicit-any
+const Temporal: any = (dntShim.dntGlobalThis as any).Temporal ??
+  new Proxy({}, { get: () => {} });
+
+/** A non-exhaustive list of prototypes that can be accurately fast-path compared with `String(instance)` */
+const stringComparablePrototypes = new Set<unknown>(
+  [
+    Intl.Locale,
+    RegExp,
+    Temporal.Duration,
+    Temporal.Instant,
+    Temporal.PlainDate,
+    Temporal.PlainDateTime,
+    Temporal.PlainTime,
+    Temporal.PlainYearMonth,
+    Temporal.PlainMonthDay,
+    Temporal.ZonedDateTime,
+    URL,
+    URLSearchParams,
+  ].filter((x) => x != null).map((x) => x.prototype),
+);
+
+function isPrimitive(x: unknown) {
+  return typeof x === "string" ||
+    typeof x === "number" ||
+    typeof x === "boolean" ||
+    typeof x === "bigint" ||
+    typeof x === "symbol" ||
+    x == null;
+}
+
+type TypedArray = Pick<Uint8Array | BigUint64Array, "length" | number>;
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+function compareTypedArrays(a: TypedArray, b: TypedArray) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < b.length; i++) {
+    if (!sameValueZero(a[i], b[i])) return false;
+  }
+  return true;
+}
+
+/** Check both strict equality (`0 == -0`) and `Object.is` (`NaN == NaN`) */
+function sameValueZero(a: unknown, b: unknown) {
+  return a === b || Object.is(a, b);
+}
+
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param a The actual value
+ * @param b The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
+ * ```
+ */
+export function equal(a: unknown, b: unknown): boolean {
+  const seen = new Map<unknown, unknown>();
+  return (function compare(a: unknown, b: unknown): boolean {
+    if (sameValueZero(a, b)) return true;
+    if (isPrimitive(a) || isPrimitive(b)) return false;
+
+    if (a instanceof Date && b instanceof Date) {
+      return Object.is(a.getTime(), b.getTime());
+    }
+    if (a && typeof a === "object" && b && typeof b === "object") {
+      if (!prototypesEqual(a, b)) {
+        return false;
+      }
+      if (a instanceof TypedArray) {
+        return compareTypedArrays(a as TypedArray, b as TypedArray);
+      }
+      if (a instanceof WeakMap) {
+        throw new TypeError("cannot compare WeakMap instances");
+      }
+      if (a instanceof WeakSet) {
+        throw new TypeError("cannot compare WeakSet instances");
+      }
+      if (a instanceof WeakRef) {
+        return compare(a.deref(), (b as WeakRef<WeakKey>).deref());
+      }
+      if (seen.get(a) === b) {
+        return true;
+      }
+      if (Object.keys(a).length !== Object.keys(b).length) {
+        return false;
+      }
+      seen.set(a, b);
+      if (isKeyedCollection(a) && isKeyedCollection(b)) {
+        if (a.size !== b.size) {
+          return false;
+        }
+
+        const aKeys = [...a.keys()];
+        const primitiveKeysFastPath = aKeys.every(isPrimitive);
+        if (primitiveKeysFastPath) {
+          if (a instanceof Set) {
+            return a.symmetricDifference(b).size === 0;
+          }
+
+          for (const key of aKeys) {
+            if (
+              !b.has(key) ||
+              !compare(a.get(key), (b as Map<unknown, unknown>).get(key))
+            ) {
+              return false;
+            }
+          }
+          return true;
+        }
+
+        let unmatchedEntries = a.size;
+
+        for (const [aKey, aValue] of a.entries()) {
+          for (const [bKey, bValue] of b.entries()) {
+            /* Given that Map keys can be references, we need
+             * to ensure that they are also deeply equal */
+
+            if (!compare(aKey, bKey)) continue;
+
+            if (
+              (aKey === aValue && bKey === bValue) ||
+              (compare(aValue, bValue))
+            ) {
+              unmatchedEntries--;
+              break;
+            }
+          }
+        }
+
+        return unmatchedEntries === 0;
+      }
+
+      let keys: Iterable<string | symbol>;
+
+      if (isBasicObjectOrArray(a)) {
+        // fast path
+        keys = ownKeys({ ...a, ...b });
+      } else if (stringComparablePrototypes.has(Object.getPrototypeOf(a))) {
+        // medium path
+        return String(a) === String(b);
+      } else {
+        // slow path
+        keys = getKeysDeep(a).union(getKeysDeep(b));
+      }
+
+      for (const key of keys) {
+        type Key = keyof typeof a;
+        if (!compare(a[key as Key], b[key as Key])) {
+          return false;
+        }
+        if (((key in a) && (!(key in b))) || ((key in b) && (!(key in a)))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  })(a, b);
+}

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

@@ -0,0 +1,26 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Filters the given array, removing all elements that do not match the given predicate
+ * **in place. This means `array` will be modified!**.
+ */
+export function filterInPlace<T>(
+  array: Array<T>,
+  predicate: (el: T) => boolean,
+): Array<T> {
+  let outputIndex = 0;
+
+  for (const cur of array) {
+    if (!predicate(cur)) {
+      continue;
+    }
+
+    array[outputIndex] = cur;
+    outputIndex += 1;
+  }
+
+  array.splice(outputIndex);
+
+  return array;
+}

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

@@ -0,0 +1,62 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { mapEntries } from "./map_entries.js";
+
+/**
+ * Applies the given aggregator to each group in the given grouping, returning the
+ * results together with the respective group keys
+ *
+ * @typeParam T Type of the values in the input record.
+ * @typeParam A Type of the accumulator value, which will match the returned
+ * record's values.
+ *
+ * @param record The grouping to aggregate.
+ * @param aggregator The function to apply to each group.
+ *
+ * @returns A record with the same keys as the input record, but with the values
+ * being the result of applying the aggregator to each group.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { aggregateGroups } from "@std/collections/aggregate-groups";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const foodProperties = {
+ *   Curry: ["spicy", "vegan"],
+ *   Omelette: ["creamy", "vegetarian"],
+ * };
+ *
+ * const descriptions = aggregateGroups(
+ *   foodProperties,
+ *   (current, key, first, acc) => {
+ *     return first
+ *       ? `${key} is ${current}`
+ *       : `${acc} and ${current}`;
+ *   },
+ * );
+ *
+ * assertEquals(descriptions, {
+ *   Curry: "Curry is spicy and vegan",
+ *   Omelette: "Omelette is creamy and vegetarian",
+ * });
+ * ```
+ */
+export function aggregateGroups<T, A>(
+  record: Readonly<Record<string, ReadonlyArray<T>>>,
+  aggregator: (current: T, key: string, first: boolean, accumulator?: A) => A,
+): Record<string, A> {
+  return mapEntries(
+    record,
+    ([key, values]) => [
+      key,
+      // Need the type assertions here because the reduce type does not support
+      // the type transition we need
+      values.reduce(
+        (accumulator, current, currentIndex) =>
+          aggregator(current, key, currentIndex === 0, accumulator),
+        undefined as A | undefined,
+      ) as A,
+    ],
+  );
+}

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

@@ -0,0 +1,50 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Creates a record by associating each element of the input array with a key
+ * generated by the selector function.
+ *
+ * If the selector produces the same key for multiple elements, the latest one
+ * will be used (overriding the ones before it).
+ *
+ * @typeParam T Type of the elements in the input array.
+ *
+ * @param array The array to transform.
+ * @param selector The function to extract the key from each element.
+ *
+ * @returns A record with the keys produced by the selector and the elements as
+ * values.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { associateBy } from "@std/collections/associate-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const users = [
+ *   { id: "a2e", userName: "Anna" },
+ *   { id: "5f8", userName: "Arnold" },
+ *   { id: "d2c", userName: "Kim" },
+ * ];
+ *
+ * const usersById = associateBy(users, (user) => user.id);
+ *
+ * assertEquals(usersById, {
+ *   "a2e": { id: "a2e", userName: "Anna" },
+ *   "5f8": { id: "5f8", userName: "Arnold" },
+ *   "d2c": { id: "d2c", userName: "Kim" },
+ * });
+ * ```
+ */
+export function associateBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => string,
+): Record<string, T> {
+  const result: Record<string, T> = {};
+
+  for (const element of array) {
+    result[selector(element)] = element;
+  }
+
+  return result;
+}

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

@@ -0,0 +1,46 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Associates each string element of an array with a value returned by a selector
+ * function.
+ *
+ * If any of two pairs would have the same value, the latest one will be used
+ * (overriding the ones before it).
+ *
+ * @typeParam T The type of the values returned by the selector function.
+ *
+ * @param array The array of elements to associate with values.
+ * @param selector The selector function that returns a value for each element.
+ *
+ * @returns An object where each element of the array is associated with a value
+ * returned by the selector function.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { associateWith } from "@std/collections/associate-with";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const names = ["Kim", "Lara", "Jonathan"];
+ *
+ * const namesToLength = associateWith(names, (person) => person.length);
+ *
+ * assertEquals(namesToLength, {
+ *   "Kim": 3,
+ *   "Lara": 4,
+ *   "Jonathan": 8,
+ * });
+ * ```
+ */
+export function associateWith<T>(
+  array: Iterable<string>,
+  selector: (key: string) => T,
+): Record<string, T> {
+  const result: Record<string, T> = {};
+
+  for (const element of array) {
+    result[element] = selector(element);
+  }
+
+  return result;
+}

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

@@ -0,0 +1,56 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Splits the given array into chunks of the given size and returns them.
+ *
+ * @typeParam T Type of the elements in the input array.
+ *
+ * @param array The array to split into chunks.
+ * @param size The size of the chunks. This must be a positive integer.
+ *
+ * @returns An array of chunks of the given size.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { chunk } from "@std/collections/chunk";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const words = [
+ *   "lorem",
+ *   "ipsum",
+ *   "dolor",
+ *   "sit",
+ *   "amet",
+ *   "consetetur",
+ *   "sadipscing",
+ * ];
+ * const chunks = chunk(words, 3);
+ *
+ * assertEquals(
+ *   chunks,
+ *   [
+ *     ["lorem", "ipsum", "dolor"],
+ *     ["sit", "amet", "consetetur"],
+ *     ["sadipscing"],
+ *   ],
+ * );
+ * ```
+ */
+export function chunk<T>(array: readonly T[], size: number): T[][] {
+  if (size <= 0 || !Number.isInteger(size)) {
+    throw new RangeError(
+      `Expected size to be an integer greater than 0 but found ${size}`,
+    );
+  }
+
+  const result: T[][] = [];
+  let index = 0;
+
+  while (index < array.length) {
+    result.push(array.slice(index, index + size));
+    index += size;
+  }
+
+  return result;
+}