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

package/src/deps/jsr.io/@std/cli/1.0.6/prompt_secret.ts

@@ -1,102 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import * as dntShim from "../../../../../_dnt.shims.js";
-
-
-const input = dntShim.Deno.stdin;
-const output = dntShim.Deno.stdout;
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-const LF = "\n".charCodeAt(0); // ^J - Enter on Linux
-const CR = "\r".charCodeAt(0); // ^M - Enter on macOS and Windows (CRLF)
-const BS = "\b".charCodeAt(0); // ^H - Backspace on Linux and Windows
-const DEL = 0x7f; // ^? - Backspace on macOS
-const CLR = encoder.encode("\r\u001b[K"); // Clear the current line
-
-// The `cbreak` option is not supported on Windows
-const setRawOptions = dntShim.Deno.build.os === "windows"
-  ? undefined
-  : { cbreak: true };
-
-/** Options for {@linkcode promptSecret}. */
-export type PromptSecretOptions = {
-  /** A character to print instead of the user's input. */
-  mask?: string;
-  /** Clear the current line after the user's input. */
-  clear?: boolean;
-};
-
-/**
- * Shows the given message and waits for the user's input. Returns the user's input as string.
- * This is similar to `prompt()` but it print user's input as `*` to prevent password from being shown.
- * Use an empty `mask` if you don't want to show any character.
- *
- * @param message The prompt message to show to the user.
- * @param options The options for the prompt.
- * @returns The string that was entered or `null` if stdin is not a TTY.
- *
- * @example Usage
- * ```ts no-eval
- * import { promptSecret } from "@std/cli/prompt-secret";
- *
- * const password = promptSecret("Please provide the password:");
- * if (password !== "some-password") {
- *   throw new Error("Access denied");
- * }
- * ```
- */
-export function promptSecret(
-  message = "Secret",
-  options?: PromptSecretOptions,
-): string | null {
-  const { mask = "*", clear } = options ?? {};
-
-  if (!input.isTerminal()) {
-    return null;
-  }
-
-  // Make the output consistent with the built-in prompt()
-  message += " ";
-  const callback = !mask ? undefined : (n: number) => {
-    output.writeSync(CLR);
-    output.writeSync(encoder.encode(`${message}${mask.repeat(n)}`));
-  };
-  output.writeSync(encoder.encode(message));
-
-  dntShim.Deno.stdin.setRaw(true, setRawOptions);
-  try {
-    return readLineFromStdinSync(callback);
-  } finally {
-    if (clear) {
-      output.writeSync(CLR);
-    } else {
-      output.writeSync(encoder.encode("\n"));
-    }
-    dntShim.Deno.stdin.setRaw(false);
-  }
-}
-
-// Slightly modified from Deno's runtime/js/41_prompt.js
-// This implementation immediately break on CR or LF and accept callback.
-// The original version waits LF when CR is received.
-// https://github.com/denoland/deno/blob/e4593873a9c791238685dfbb45e64b4485884174/runtime/js/41_prompt.js#L52-L77
-function readLineFromStdinSync(callback?: (n: number) => void): string {
-  const c = new Uint8Array(1);
-  const buf = [];
-
-  while (true) {
-    const n = input.readSync(c);
-    if (n === null || n === 0) {
-      break;
-    }
-    if (c[0] === CR || c[0] === LF) {
-      break;
-    }
-    if (c[0] === BS || c[0] === DEL) {
-      buf.pop();
-    } else {
-      buf.push(c[0]!);
-    }
-    if (callback) callback(buf.length);
-  }
-  return decoder.decode(new Uint8Array(buf));
-}

package/src/deps/jsr.io/@std/cli/1.0.6/unicode_width.ts

@@ -1,79 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-// Ported from unicode_width rust crate, Copyright (c) 2015 The Rust Project Developers. MIT license.
-
-import data from "./_data.js";
-import { runLengthDecode } from "./_run_length.js";
-
-let tables: Uint8Array[] | null = null;
-function lookupWidth(cp: number) {
-  if (!tables) tables = data.tables.map(runLengthDecode);
-  const t1Offset = tables[0]![(cp >> 13) & 0xff]!;
-  const t2Offset = tables[1]![128 * t1Offset + ((cp >> 6) & 0x7f)]!;
-  const packedWidths = tables[2]![16 * t2Offset + ((cp >> 2) & 0xf)]!;
-
-  const width = (packedWidths >> (2 * (cp & 0b11))) & 0b11;
-
-  return width === 3 ? 1 : width;
-}
-
-const cache = new Map<string, number | null>();
-function charWidth(char: string) {
-  if (cache.has(char)) return cache.get(char)!;
-
-  const codePoint = char.codePointAt(0)!;
-  let width: number | null = null;
-
-  if (codePoint < 0x7f) {
-    width = codePoint >= 0x20 ? 1 : codePoint === 0 ? 0 : null;
-  } else if (codePoint >= 0xa0) {
-    width = lookupWidth(codePoint);
-  } else {
-    width = null;
-  }
-
-  cache.set(char, width);
-  return width;
-}
-
-/**
- * Calculate the physical width of a string in a TTY-like environment. This is
- * useful for cases such as calculating where a line-wrap will occur and
- * underlining strings.
- *
- * The physical width is given by the number of columns required to display
- * the string. The number of columns a given unicode character occupies can
- * vary depending on the character itself.
- *
- * @param str The string to measure.
- * @returns The unicode width of the string.
- *
- * @example Calculating the unicode width of a string
- * ```ts
- * import { unicodeWidth } from "@std/cli/unicode-width";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(unicodeWidth("hello world"), 11);
- * assertEquals(unicodeWidth("天地玄黃宇宙洪荒"), 16);
- * assertEquals(unicodeWidth("ｆｕｌｌｗｉｄｔｈ"), 18);
- * ```
- *
- * @example Calculating the unicode width of a color-encoded string
- * ```ts
- * import { unicodeWidth } from "@std/cli/unicode-width";
- * import { stripAnsiCode } from "@std/fmt/colors";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(unicodeWidth(stripAnsiCode("\x1b[36mголубой\x1b[39m")), 7);
- * assertEquals(unicodeWidth(stripAnsiCode("\x1b[31m紅色\x1b[39m")), 4);
- * assertEquals(unicodeWidth(stripAnsiCode("\x1B]8;;https://deno.land\x07🦕\x1B]8;;\x07")), 2);
- * ```
- *
- * Use
- * {@linkcode https://jsr.io/@std/fmt/doc/colors/~/stripAnsiCode | stripAnsiCode}
- * to remove ANSI escape codes from a string before passing it to
- * {@linkcode unicodeWidth}.
- */
-export function unicodeWidth(str: string): number {
-  return [...str].map((ch) => charWidth(ch) ?? 0).reduce((a, b) => a + b, 0);
-}

package/src/deps/jsr.io/@std/dotenv/0.225.2/load.ts

@@ -1,14 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import * as dntShim from "../../../../../_dnt.shims.js";
-
-
-import { loadSync } from "./mod.js";
-
-if (!(dntShim.Deno.readTextFileSync instanceof Function)) {
-  // Avoid errors that occur in deno deploy: https://github.com/denoland/deno_std/issues/1957
-  console.warn(
-    `Deno.readTextFileSync is not a function: No .env data was read.`,
-  );
-} else {
-  loadSync({ export: true });
-}

package/src/deps/jsr.io/@std/dotenv/0.225.2/mod.ts

@@ -1,251 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-/**
- * Parses and loads environment variables from a `.env` file into the current
- * process, or stringify data into a `.env` file format.
- *
- * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
- *
- * ```ts no-eval
- * // Automatically load environment variables from a `.env` file
- * import "@std/dotenv/load";
- * ```
- *
- * ```ts
- * import { parse, stringify } from "@std/dotenv";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(parse("GREETING=hello world"), { GREETING: "hello world" });
- * assertEquals(stringify({ GREETING: "hello world" }), "GREETING='hello world'");
- * ```
- *
- * @module
- */
-import * as dntShim from "../../../../../_dnt.shims.js";
-
-
-import { parse } from "./parse.js";
-
-export * from "./stringify.js";
-export * from "./parse.js";
-
-/** Options for {@linkcode load} and {@linkcode loadSync}. */
-export interface LoadOptions {
-  /**
-   * Optional path to `.env` file. To prevent the default value from being
-   * used, set to `null`.
-   *
-   * @default {"./.env"}
-   */
-  envPath?: string | null;
-
-  /**
-   * Set to `true` to export all `.env` variables to the current processes
-   * environment. Variables are then accessible via `Deno.env.get(<key>)`.
-   *
-   * @default {false}
-   */
-  export?: boolean;
-}
-
-/**
- * Works identically to {@linkcode load}, but synchronously.
- *
- * @example Usage
- * ```ts no-eval
- * import { loadSync } from "@std/dotenv";
- *
- * const conf = loadSync();
- * ```
- *
- * @param options Options for loading the environment variables.
- * @returns The parsed environment variables.
- */
-export function loadSync(
-  options: LoadOptions = {},
-): Record<string, string> {
-  const {
-    envPath = ".env",
-    export: _export = false,
-  } = options;
-  const conf = envPath ? parseFileSync(envPath) : {};
-
-  if (_export) {
-    for (const [key, value] of Object.entries(conf)) {
-      if (dntShim.Deno.env.get(key) !== undefined) continue;
-      dntShim.Deno.env.set(key, value);
-    }
-  }
-
-  return conf;
-}
-
-/**
- * Load environment variables from a `.env` file.  Loaded variables are accessible
- * in a configuration object returned by the `load()` function, as well as optionally
- * exporting them to the process environment using the `export` option.
- *
- * Inspired by the node modules {@linkcode https://github.com/motdotla/dotenv | dotenv}
- * and {@linkcode https://github.com/motdotla/dotenv-expand | dotenv-expand}.
- *
- * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
- *
- * ## Basic usage
- * ```sh
- * # .env
- * GREETING=hello world
- * ```
- *
- * Then import the environment variables using the `load` function.
- *
- * @example Basic usage
- * ```ts no-eval
- * // app.ts
- * import { load } from "@std/dotenv";
- *
- * console.log(await load({ export: true })); // { GREETING: "hello world" }
- * console.log(Deno.env.get("GREETING")); // hello world
- * ```
- *
- * Run this with `deno run --allow-read --allow-env app.ts`.
- *
- * .env files support blank lines, comments, multi-line values and more.
- * See Parsing Rules below for more detail.
- *
- * ## Auto loading
- * Import the `load.ts` module to auto-import from the `.env` file and into
- * the process environment.
- *
- * @example Auto-loading
- * ```ts no-eval
- * // app.ts
- * import "@std/dotenv/load";
- *
- * console.log(Deno.env.get("GREETING")); // hello world
- * ```
- *
- * Run this with `deno run --allow-read --allow-env app.ts`.
- *
- * ## Files
- * Dotenv supports a number of different files, all of which are optional.
- * File names and paths are configurable.
- *
- * |File|Purpose|
- * |----|-------|
- * |.env|primary file for storing key-value environment entries
- *
- * ## Configuration
- *
- * Loading environment files comes with a number of options passed into
- * the `load()` function, all of which are optional.
- *
- * |Option|Default|Description
- * |------|-------|-----------
- * |envPath|./.env|Path and filename of the `.env` file.  Use null to prevent the .env file from being loaded.
- * |export|false|When true, this will export all environment variables in the `.env` file to the process environment (e.g. for use by `Deno.env.get()`) but only if they are not already set.  If a variable is already in the process, the `.env` value is ignored.
- *
- * ### Example configuration
- *
- * @example Using with options
- * ```ts no-eval
- * import { load } from "@std/dotenv";
- *
- * const conf = await load({
- *   envPath: "./.env_prod", // Uses .env_prod instead of .env
- *   export: true, // Exports all variables to the environment
- * });
- * ```
- *
- * ## Permissions
- *
- * At a minimum, loading the `.env` related files requires the `--allow-read` permission.  Additionally, if
- * you access the process environment, either through exporting your configuration or expanding variables
- * in your `.env` file, you will need the `--allow-env` permission.  E.g.
- *
- * ```sh
- * deno run --allow-read=.env --allow-env=ENV1,ENV2 app.ts
- * ```
- *
- * ## Parsing Rules
- *
- * The parsing engine currently supports the following rules:
- *
- * - Variables that already exist in the environment are not overridden with
- *   `export: true`
- * - `BASIC=basic` becomes `{ BASIC: "basic" }`
- * - empty lines are skipped
- * - lines beginning with `#` are treated as comments
- * - empty values become empty strings (`EMPTY=` becomes `{ EMPTY: "" }`)
- * - single and double quoted values are escaped (`SINGLE_QUOTE='quoted'` becomes
- *   `{ SINGLE_QUOTE: "quoted" }`)
- * - new lines are expanded in double quoted values (`MULTILINE="new\nline"`
- *   becomes
- *
- * ```
- * { MULTILINE: "new\nline" }
- * ```
- *
- * - inner quotes are maintained (think JSON) (`JSON={"foo": "bar"}` becomes
- *   `{ JSON: "{\"foo\": \"bar\"}" }`)
- * - whitespace is removed from both ends of unquoted values (see more on
- *   {@linkcode https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim | trim})
- *   (`FOO= some value` becomes `{ FOO: "some value" }`)
- * - whitespace is preserved on both ends of quoted values (`FOO=" some value "`
- *   becomes `{ FOO: " some value " }`)
- * - dollar sign with an environment key in or without curly braces in unquoted
- *   values will expand the environment key (`KEY=$KEY` or `KEY=${KEY}` becomes
- *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }`)
- * - escaped dollar sign with an environment key in unquoted values will escape the
- *   environment key rather than expand (`KEY=\$KEY` becomes `{ KEY: "\\$KEY" }`)
- * - colon and a minus sign with a default value(which can also be another expand
- *   value) in expanding construction in unquoted values will first attempt to
- *   expand the environment key. If it’s not found, then it will return the default
- *   value (`KEY=${KEY:-default}` If KEY exists it becomes
- *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }` If not, then it becomes
- *   `{ KEY: "default" }`. Also there is possible to do this case
- *   `KEY=${NO_SUCH_KEY:-${EXISTING_KEY:-default}}` which becomes
- *   `{ KEY: "<EXISTING_KEY_VALUE_FROM_ENV>" }`)
- *
- * @param options The options
- * @returns The parsed environment variables
- */
-export async function load(
-  options: LoadOptions = {},
-): Promise<Record<string, string>> {
-  const {
-    envPath = ".env",
-    export: _export = false,
-  } = options;
-  const conf = envPath ? await parseFile(envPath) : {};
-
-  if (_export) {
-    for (const [key, value] of Object.entries(conf)) {
-      if (dntShim.Deno.env.get(key) !== undefined) continue;
-      dntShim.Deno.env.set(key, value);
-    }
-  }
-
-  return conf;
-}
-
-function parseFileSync(
-  filepath: string,
-): Record<string, string> {
-  try {
-    return parse(dntShim.Deno.readTextFileSync(filepath));
-  } catch (e) {
-    if (e instanceof dntShim.Deno.errors.NotFound) return {};
-    throw e;
-  }
-}
-
-async function parseFile(
-  filepath: string,
-): Promise<Record<string, string>> {
-  try {
-    return parse(await dntShim.Deno.readTextFile(filepath));
-  } catch (e) {
-    if (e instanceof dntShim.Deno.errors.NotFound) return {};
-    throw e;
-  }
-}

package/src/deps/jsr.io/@std/dotenv/0.225.2/parse.ts

@@ -1,113 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import * as dntShim from "../../../../../_dnt.shims.js";
-
-
-type LineParseResult = {
-  key: string;
-  unquoted: string;
-  interpolated: string;
-  notInterpolated: string;
-};
-
-type CharactersMap = { [key: string]: string };
-
-const RE_KEY_VALUE =
-  /^\s*(?:export\s+)?(?<key>[^\s=#]+?)\s*=[\ \t]*('\n?(?<notInterpolated>(.|\n)*?)\n?'|"\n?(?<interpolated>(.|\n)*?)\n?"|(?<unquoted>[^\n#]*)) *#*.*$/gm;
-
-const RE_VALID_KEY = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-
-const RE_EXPAND_VALUE =
-  /(\${(?<inBrackets>.+?)(\:-(?<inBracketsDefault>.+))?}|(?<!\\)\$(?<notInBrackets>\w+)(\:-(?<notInBracketsDefault>.+))?)/g;
-
-function expandCharacters(str: string): string {
-  const charactersMap: CharactersMap = {
-    "\\n": "\n",
-    "\\r": "\r",
-    "\\t": "\t",
-  };
-
-  return str.replace(
-    /\\([nrt])/g,
-    ($1: keyof CharactersMap): string => charactersMap[$1] ?? "",
-  );
-}
-
-function expand(str: string, variablesMap: { [key: string]: string }): string {
-  if (RE_EXPAND_VALUE.test(str)) {
-    return expand(
-      str.replace(RE_EXPAND_VALUE, function (...params) {
-        const {
-          inBrackets,
-          inBracketsDefault,
-          notInBrackets,
-          notInBracketsDefault,
-        } = params[params.length - 1];
-        const expandValue = inBrackets || notInBrackets;
-        const defaultValue = inBracketsDefault || notInBracketsDefault;
-
-        let value: string | undefined = variablesMap[expandValue];
-        if (value === undefined) {
-          value = dntShim.Deno.env.get(expandValue);
-        }
-        return value === undefined ? expand(defaultValue, variablesMap) : value;
-      }),
-      variablesMap,
-    );
-  } else {
-    return str;
-  }
-}
-
-/**
- * Parse `.env` file output in an object.
- *
- * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
- *
- * @example Usage
- * ```ts
- * import { parse } from "@std/dotenv/parse";
- * import { assertEquals } from "@std/assert";
- *
- * const env = parse("GREETING=hello world");
- * assertEquals(env, { GREETING: "hello world" });
- * ```
- *
- * @param text The text to parse.
- * @returns The parsed object.
- */
-export function parse(text: string): Record<string, string> {
-  const env: Record<string, string> = {};
-
-  let match;
-  const keysForExpandCheck = [];
-
-  while ((match = RE_KEY_VALUE.exec(text)) !== null) {
-    const { key, interpolated, notInterpolated, unquoted } = match
-      ?.groups as LineParseResult;
-
-    if (!RE_VALID_KEY.test(key)) {
-      console.warn(
-        `Ignored the key "${key}" as it is not a valid identifier: The key need to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.`,
-      );
-      continue;
-    }
-
-    if (unquoted) {
-      keysForExpandCheck.push(key);
-    }
-
-    env[key] = typeof notInterpolated === "string"
-      ? notInterpolated
-      : typeof interpolated === "string"
-      ? expandCharacters(interpolated)
-      : unquoted.trim();
-  }
-
-  //https://github.com/motdotla/dotenv-expand/blob/ed5fea5bf517a09fd743ce2c63150e88c8a5f6d1/lib/main.js#L23
-  const variablesMap = { ...env };
-  keysForExpandCheck.forEach((key) => {
-    env[key] = expand(env[key]!, variablesMap);
-  });
-
-  return env;
-}

package/src/deps/jsr.io/@std/dotenv/0.225.2/stringify.ts

@@ -1,47 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-/**
- * Stringify an object into a valid `.env` file format.
- *
- * @example Usage
- * ```ts
- * import { stringify } from "@std/dotenv/stringify";
- * import { assertEquals } from "@std/assert";
- *
- * const object = { GREETING: "hello world" };
- * assertEquals(stringify(object), "GREETING='hello world'");
- * ```
- *
- * @param object object to be stringified
- * @returns string of object
- */
-export function stringify(object: Record<string, string>): string {
-  const lines: string[] = [];
-  for (const [key, value] of Object.entries(object)) {
-    let quote;
-
-    let escapedValue = value ?? "";
-    if (key.startsWith("#")) {
-      console.warn(
-        `key starts with a '#' indicates a comment and is ignored: '${key}'`,
-      );
-      continue;
-    } else if (escapedValue.includes("\n") || escapedValue.includes("'")) {
-      // escape inner new lines
-      escapedValue = escapedValue.replaceAll("\n", "\\n");
-      quote = `"`;
-    } else if (escapedValue.match(/\W/)) {
-      quote = "'";
-    }
-
-    if (quote) {
-      // escape inner quotes
-      escapedValue = escapedValue.replaceAll(quote, `\\${quote}`);
-      escapedValue = `${quote}${escapedValue}${quote}`;
-    }
-    const line = `${key}=${escapedValue}`;
-    lines.push(line);
-  }
-  return lines.join("\n");
-}

package/src/deps/jsr.io/@std/fs/1.0.5/_create_walk_entry.ts

@@ -1,47 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// Copyright the Browserify authors. MIT License.
-import * as dntShim from "../../../../../_dnt.shims.js";
-
-
-import { basename } from "../../path/1.0.8/basename.js";
-import { normalize } from "../../path/1.0.8/normalize.js";
-import { toPathString } from "./_to_path_string.js";
-
-/**
- * Walk entry for {@linkcode walk}, {@linkcode walkSync},
- * {@linkcode expandGlob} and {@linkcode expandGlobSync}.
- */
-export interface WalkEntry extends dntShim.Deno.DirEntry {
-  /** Full path of the entry. */
-  path: string;
-}
-
-/** Create {@linkcode WalkEntry} for the `path` synchronously. */
-export function createWalkEntrySync(path: string | URL): WalkEntry {
-  path = toPathString(path);
-  path = normalize(path);
-  const name = basename(path);
-  const info = dntShim.Deno.statSync(path);
-  return {
-    path,
-    name,
-    isFile: info.isFile,
-    isDirectory: info.isDirectory,
-    isSymlink: info.isSymlink,
-  };
-}
-
-/** Create {@linkcode WalkEntry} for the `path` asynchronously. */
-export async function createWalkEntry(path: string | URL): Promise<WalkEntry> {
-  path = toPathString(path);
-  path = normalize(path);
-  const name = basename(path);
-  const info = await dntShim.Deno.stat(path);
-  return {
-    path,
-    name,
-    isFile: info.isFile,
-    isDirectory: info.isDirectory,
-    isSymlink: info.isSymlink,
-  };
-}

package/src/deps/jsr.io/@std/fs/1.0.5/_get_file_info_type.ts

@@ -1,25 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// Copyright the Browserify authors. MIT License.
-import * as dntShim from "../../../../../_dnt.shims.js";
-
-
-export type PathType = "file" | "dir" | "symlink";
-
-/**
- * Get a human readable file type string.
- *
- * @param file File information, as returned by {@linkcode Deno.stat} or
- * {@linkcode Deno.lstat}.
- *
- * @returns The file type as a string, or `undefined` if the file type is
- * unknown.
- */
-export function getFileInfoType(fileInfo: dntShim.Deno.FileInfo): PathType | undefined {
-  return fileInfo.isFile
-    ? "file"
-    : fileInfo.isDirectory
-    ? "dir"
-    : fileInfo.isSymlink
-    ? "symlink"
-    : undefined;
-}