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

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

@@ -1,31 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-/**
- * Error thrown when an assertion fails.
- *
- * @example Usage
- * ```ts ignore
- * import { AssertionError } from "@std/assert";
- *
- * try {
- *   throw new AssertionError("foo", { cause: "bar" });
- * } catch (error) {
- *   if (error instanceof AssertionError) {
- *     error.message === "foo"; // true
- *     error.cause === "bar"; // true
- *   }
- * }
- * ```
- */
-export class AssertionError extends Error {
-  /** Constructs a new instance.
-   *
-   * @param message The error message.
-   * @param options Additional options. This argument is still unstable. It may change in the future release.
-   */
-  constructor(message: string, options?: ErrorOptions) {
-    super(message, options);
-    this.name = "AssertionError";
-  }
-}

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

@@ -1,210 +0,0 @@
-// 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/assert/1.0.8/equals.ts

@@ -1,52 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { equal } from "./equal.js";
-import { buildMessage } from "../../internal/1.0.5/build_message.js";
-import { diff } from "../../internal/1.0.5/diff.js";
-import { diffStr } from "../../internal/1.0.5/diff_str.js";
-import { format } from "../../internal/1.0.5/format.js";
-
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` and `expected` are equal, deeply. If not
- * deeply equal, then throw.
- *
- * Type parameter can be specified to ensure values under comparison have the
- * same type.
- *
- * @example Usage
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals("world", "world"); // Doesn't throw
- * assertEquals("hello", "world"); // Throws
- * ```
- *
- * @typeParam T The type of the values to compare. This is usually inferred.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertEquals<T>(
-  actual: T,
-  expected: T,
-  msg?: string,
-) {
-  if (equal(actual, expected)) {
-    return;
-  }
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  let message = `Values are not equal${msgSuffix}`;
-
-  const actualString = format(actual);
-  const expectedString = format(expected);
-  const stringDiff = (typeof actual === "string") &&
-    (typeof expected === "string");
-  const diffResult = stringDiff
-    ? diffStr(actual as string, expected as string)
-    : diff(actualString.split("\n"), expectedString.split("\n"));
-  const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
-  message = `${message}\n${diffMsg}`;
-  throw new AssertionError(message);
-}

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

@@ -1,31 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that actual is not null or undefined.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertExists } from "@std/assert";
- *
- * assertExists("something"); // Doesn't throw
- * assertExists(undefined); // Throws
- * ```
- *
- * @typeParam T The type of the actual value.
- * @param actual The actual value to check.
- * @param msg The optional message to include in the error if the assertion fails.
- */
-export function assertExists<T>(
-  actual: T,
-  msg?: string,
-): asserts actual is NonNullable<T> {
-  if (actual === undefined || actual === null) {
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    msg =
-      `Expected actual: "${actual}" to not be null or undefined${msgSuffix}`;
-    throw new AssertionError(msg);
-  }
-}

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

@@ -1,21 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Forcefully throws a failed assertion.
- *
- * @example Usage
- * ```ts ignore
- * import { fail } from "@std/assert";
- *
- * fail("Deliberately failed!"); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export function fail(msg?: string): never {
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  throw new AssertionError(`Failed assertion${msgSuffix}`);
-}

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

@@ -1,26 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/** Assertion condition for {@linkcode assertFalse}. */
-export type Falsy = false | 0 | 0n | "" | null | undefined;
-
-/**
- * Make an assertion, error will be thrown if `expr` have truthy value.
- *
- * @example Usage
- * ```ts ignore
- * import { assertFalse } from "@std/assert";
- *
- * assertFalse(false); // Doesn't throw
- * assertFalse(true); // Throws
- * ```
- *
- * @param expr The expression to test.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertFalse(expr: unknown, msg = ""): asserts expr is Falsy {
-  if (expr) {
-    throw new AssertionError(msg);
-  }
-}

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

@@ -1,30 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` is greater than `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertGreater } from "@std/assert";
- *
- * assertGreater(2, 1); // Doesn't throw
- * assertGreater(1, 1); // Throws
- * assertGreater(0, 1); // Throws
- * ```
- *
- * @typeParam T The type of the values to compare.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertGreater<T>(actual: T, expected: T, msg?: string) {
-  if (actual > expected) return;
-
-  const actualString = format(actual);
-  const expectedString = format(expected);
-  throw new AssertionError(msg ?? `Expect ${actualString} > ${expectedString}`);
-}

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

@@ -1,36 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` is greater than or equal to `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertGreaterOrEqual } from "@std/assert";
- *
- * assertGreaterOrEqual(2, 1); // Doesn't throw
- * assertGreaterOrEqual(1, 1); // Doesn't throw
- * assertGreaterOrEqual(0, 1); // Throws
- * ```
- *
- * @typeParam T The type of the values to compare.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertGreaterOrEqual<T>(
-  actual: T,
-  expected: T,
-  msg?: string,
-) {
-  if (actual >= expected) return;
-
-  const actualString = format(actual);
-  const expectedString = format(expected);
-  throw new AssertionError(
-    msg ?? `Expect ${actualString} >= ${expectedString}`,
-  );
-}

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

@@ -1,64 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/** Any constructor */
-// deno-lint-ignore no-explicit-any
-export type AnyConstructor = new (...args: any[]) => any;
-/** Gets constructor type */
-export type GetConstructorType<T extends AnyConstructor> = InstanceType<T>;
-
-/**
- * Make an assertion that `obj` is an instance of `type`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertInstanceOf } from "@std/assert";
- *
- * assertInstanceOf(new Date(), Date); // Doesn't throw
- * assertInstanceOf(new Date(), Number); // Throws
- * ```
- *
- * @typeParam T The expected type of the object.
- * @param actual The object to check.
- * @param expectedType The expected class constructor.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertInstanceOf<
-  // deno-lint-ignore no-explicit-any
-  T extends abstract new (...args: any[]) => any,
->(
-  actual: unknown,
-  expectedType: T,
-  msg = "",
-): asserts actual is InstanceType<T> {
-  if (actual instanceof expectedType) return;
-
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  const expectedTypeStr = expectedType.name;
-
-  let actualTypeStr = "";
-  if (actual === null) {
-    actualTypeStr = "null";
-  } else if (actual === undefined) {
-    actualTypeStr = "undefined";
-  } else if (typeof actual === "object") {
-    actualTypeStr = actual.constructor?.name ?? "Object";
-  } else {
-    actualTypeStr = typeof actual;
-  }
-
-  if (expectedTypeStr === actualTypeStr) {
-    msg =
-      `Expected object to be an instance of "${expectedTypeStr}"${msgSuffix}`;
-  } else if (actualTypeStr === "function") {
-    msg =
-      `Expected object to be an instance of "${expectedTypeStr}" but was not an instanced object${msgSuffix}`;
-  } else {
-    msg =
-      `Expected object to be an instance of "${expectedTypeStr}" but was "${actualTypeStr}"${msgSuffix}`;
-  }
-
-  throw new AssertionError(msg);
-}

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

@@ -1,65 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-import { stripAnsiCode } from "../../internal/1.0.5/styles.js";
-
-/**
- * Make an assertion that `error` is an `Error`.
- * If not then an error will be thrown.
- * An error class and a string that should be included in the
- * error message can also be asserted.
- *
- * @example Usage
- * ```ts ignore
- * import { assertIsError } from "@std/assert";
- *
- * assertIsError(null); // Throws
- * assertIsError(new RangeError("Out of range")); // Doesn't throw
- * assertIsError(new RangeError("Out of range"), SyntaxError); // Throws
- * assertIsError(new RangeError("Out of range"), SyntaxError, "Out of range"); // Doesn't throw
- * assertIsError(new RangeError("Out of range"), SyntaxError, "Within range"); // Throws
- * ```
- *
- * @typeParam E The type of the error to assert.
- * @param error The error to assert.
- * @param ErrorClass The optional error class to assert.
- * @param msgMatches The optional string or RegExp to assert in the error message.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertIsError<E extends Error = Error>(
-  error: unknown,
-  // deno-lint-ignore no-explicit-any
-  ErrorClass?: abstract new (...args: any[]) => E,
-  msgMatches?: string | RegExp,
-  msg?: string,
-): asserts error is E {
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  if (!(error instanceof Error)) {
-    throw new AssertionError(
-      `Expected "error" to be an Error object${msgSuffix}`,
-    );
-  }
-  if (ErrorClass && !(error instanceof ErrorClass)) {
-    msg =
-      `Expected error to be instance of "${ErrorClass.name}", but was "${error?.constructor?.name}"${msgSuffix}`;
-    throw new AssertionError(msg);
-  }
-  let msgCheck;
-  if (typeof msgMatches === "string") {
-    msgCheck = stripAnsiCode(error.message).includes(
-      stripAnsiCode(msgMatches),
-    );
-  }
-  if (msgMatches instanceof RegExp) {
-    msgCheck = msgMatches.test(stripAnsiCode(error.message));
-  }
-
-  if (msgMatches && !msgCheck) {
-    msg = `Expected error message to include ${
-      msgMatches instanceof RegExp
-        ? msgMatches.toString()
-        : JSON.stringify(msgMatches)
-    }, but got ${JSON.stringify(error?.message)}${msgSuffix}`;
-    throw new AssertionError(msg);
-  }
-}

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

@@ -1,29 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` is less than `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertLess } from "@std/assert";
- *
- * assertLess(1, 2); // Doesn't throw
- * assertLess(2, 1); // Throws
- * ```
- *
- * @typeParam T The type of the values to compare.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertLess<T>(actual: T, expected: T, msg?: string) {
-  if (actual < expected) return;
-
-  const actualString = format(actual);
-  const expectedString = format(expected);
-  throw new AssertionError(msg ?? `Expect ${actualString} < ${expectedString}`);
-}

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

@@ -1,36 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` is less than or equal to `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertLessOrEqual } from "@std/assert";
- *
- * assertLessOrEqual(1, 2); // Doesn't throw
- * assertLessOrEqual(1, 1); // Doesn't throw
- * assertLessOrEqual(1, 0); // Throws
- * ```
- *
- * @typeParam T The type of the values to compare.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertLessOrEqual<T>(
-  actual: T,
-  expected: T,
-  msg?: string,
-) {
-  if (actual <= expected) return;
-
-  const actualString = format(actual);
-  const expectedString = format(expected);
-  throw new AssertionError(
-    msg ?? `Expect ${actualString} <= ${expectedString}`,
-  );
-}

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

@@ -1,30 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` match RegExp `expected`. If not
- * then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertMatch } from "@std/assert";
- *
- * assertMatch("Raptor", /Raptor/); // Doesn't throw
- * assertMatch("Denosaurus", /Raptor/); // Throws
- * ```
- *
- * @param actual The actual value to be matched.
- * @param expected The expected pattern to match.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertMatch(
-  actual: string,
-  expected: RegExp,
-  msg?: string,
-) {
-  if (expected.test(actual)) return;
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  msg = `Expected actual: "${actual}" to match: "${expected}"${msgSuffix}`;
-  throw new AssertionError(msg);
-}