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

package/src/deps/jsr.io/@std/path/1.0.8/windows/normalize_glob.ts

@@ -1,43 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import type { GlobOptions } from "../_common/glob_to_reg_exp.js";
-import { normalize } from "./normalize.js";
-import { SEPARATOR_PATTERN } from "./constants.js";
-
-export type { GlobOptions };
-
-/**
- * Like normalize(), but doesn't collapse "**\/.." when `globstar` is true.
- *
- * @example Usage
- * ```ts
- * import { normalizeGlob } from "@std/path/windows/normalize-glob";
- * import { assertEquals } from "@std/assert";
- *
- * const normalized = normalizeGlob("**\\foo\\..\\bar", { globstar: true });
- * assertEquals(normalized, "**\\bar");
- * ```
- *
- * @param glob The glob pattern to normalize.
- * @param options The options for glob pattern.
- * @returns The normalized glob pattern.
- */
-export function normalizeGlob(
-  glob: string,
-  options: Pick<GlobOptions, "globstar"> = {},
-): string {
-  const { globstar = false }: GlobOptions = options;
-  if (glob.match(/\0/g)) {
-    throw new Error(`Glob contains invalid characters: "${glob}"`);
-  }
-  if (!globstar) {
-    return normalize(glob);
-  }
-  const s = SEPARATOR_PATTERN.source;
-  const badParentPattern = new RegExp(
-    `(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`,
-    "g",
-  );
-  return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
-}

package/src/deps/jsr.io/@std/path/1.0.8/windows/parse.ts

@@ -1,184 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { CHAR_COLON, CHAR_DOT } from "../_common/constants.js";
-import type { ParsedPath } from "../types.js";
-import { assertPath } from "../_common/assert_path.js";
-import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
-
-export type { ParsedPath } from "../types.js";
-
-/**
- * Return a `ParsedPath` object of the `path`.
- *
- * @example Usage
- * ```ts
- * import { parse } from "@std/path/windows/parse";
- * import { assertEquals } from "@std/assert";
- *
- * const parsed = parse("C:\\foo\\bar\\baz.ext");
- * assertEquals(parsed, {
- *   root: "C:\\",
- *   dir: "C:\\foo\\bar",
- *   base: "baz.ext",
- *   ext: ".ext",
- *   name: "baz",
- * });
- * ```
- *
- * @param path The path to parse.
- * @returns The `ParsedPath` object.
- */
-export function parse(path: string): ParsedPath {
-  assertPath(path);
-
-  const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" };
-
-  const len = path.length;
-  if (len === 0) return ret;
-
-  let rootEnd = 0;
-  let code = path.charCodeAt(0);
-
-  // Try to match a root
-  if (len > 1) {
-    if (isPathSeparator(code)) {
-      // Possible UNC root
-
-      rootEnd = 1;
-      if (isPathSeparator(path.charCodeAt(1))) {
-        // Matched double path separator at beginning
-        let j = 2;
-        let last = j;
-        // Match 1 or more non-path separators
-        for (; j < len; ++j) {
-          if (isPathSeparator(path.charCodeAt(j))) break;
-        }
-        if (j < len && j !== last) {
-          // Matched!
-          last = j;
-          // Match 1 or more path separators
-          for (; j < len; ++j) {
-            if (!isPathSeparator(path.charCodeAt(j))) break;
-          }
-          if (j < len && j !== last) {
-            // Matched!
-            last = j;
-            // Match 1 or more non-path separators
-            for (; j < len; ++j) {
-              if (isPathSeparator(path.charCodeAt(j))) break;
-            }
-            if (j === len) {
-              // We matched a UNC root only
-
-              rootEnd = j;
-            } else if (j !== last) {
-              // We matched a UNC root with leftovers
-
-              rootEnd = j + 1;
-            }
-          }
-        }
-      }
-    } else if (isWindowsDeviceRoot(code)) {
-      // Possible device root
-
-      if (path.charCodeAt(1) === CHAR_COLON) {
-        rootEnd = 2;
-        if (len > 2) {
-          if (isPathSeparator(path.charCodeAt(2))) {
-            if (len === 3) {
-              // `path` contains just a drive root, exit early to avoid
-              // unnecessary work
-              ret.root = ret.dir = path;
-              ret.base = "\\";
-              return ret;
-            }
-            rootEnd = 3;
-          }
-        } else {
-          // `path` contains just a relative drive root, exit early to avoid
-          // unnecessary work
-          ret.root = ret.dir = path;
-          return ret;
-        }
-      }
-    }
-  } else if (isPathSeparator(code)) {
-    // `path` contains just a path separator, exit early to avoid
-    // unnecessary work
-    ret.root = ret.dir = path;
-    ret.base = "\\";
-    return ret;
-  }
-
-  if (rootEnd > 0) ret.root = path.slice(0, rootEnd);
-
-  let startDot = -1;
-  let startPart = rootEnd;
-  let end = -1;
-  let matchedSlash = true;
-  let i = path.length - 1;
-
-  // Track the state of characters (if any) we see before our first dot and
-  // after any path separator we find
-  let preDotState = 0;
-
-  // Get non-dir info
-  for (; i >= rootEnd; --i) {
-    code = path.charCodeAt(i);
-    if (isPathSeparator(code)) {
-      // If we reached a path separator that was not part of a set of path
-      // separators at the end of the string, stop now
-      if (!matchedSlash) {
-        startPart = i + 1;
-        break;
-      }
-      continue;
-    }
-    if (end === -1) {
-      // We saw the first non-path separator, mark this as the end of our
-      // extension
-      matchedSlash = false;
-      end = i + 1;
-    }
-    if (code === CHAR_DOT) {
-      // If this is our first dot, mark it as the start of our extension
-      if (startDot === -1) startDot = i;
-      else if (preDotState !== 1) preDotState = 1;
-    } else if (startDot !== -1) {
-      // We saw a non-dot and non-path separator before our dot, so we should
-      // have a good chance at having a non-empty extension
-      preDotState = -1;
-    }
-  }
-
-  if (
-    startDot === -1 ||
-    end === -1 ||
-    // We saw a non-dot character immediately before the dot
-    preDotState === 0 ||
-    // The (right-most) trimmed path component is exactly '..'
-    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
-  ) {
-    if (end !== -1) {
-      ret.base = ret.name = path.slice(startPart, end);
-    }
-  } else {
-    ret.name = path.slice(startPart, startDot);
-    ret.base = path.slice(startPart, end);
-    ret.ext = path.slice(startDot, end);
-  }
-
-  // Fallback to '\' in case there is no basename
-  ret.base = ret.base || "\\";
-
-  // If the directory is the root, use the entire root as the `dir` including
-  // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
-  // trailing slash (`C:\abc\def` -> `C:\abc`).
-  if (startPart > 0 && startPart !== rootEnd) {
-    ret.dir = path.slice(0, startPart - 1);
-  } else ret.dir = ret.root;
-
-  return ret;
-}

package/src/deps/jsr.io/@std/path/1.0.8/windows/relative.ts

@@ -1,128 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { CHAR_BACKWARD_SLASH } from "../_common/constants.js";
-import { resolve } from "./resolve.js";
-import { assertArgs } from "../_common/relative.js";
-
-/**
- * Return the relative path from `from` to `to` based on current working directory.
- *
- * An example in windws, for instance:
- *  from = 'C:\\orandea\\test\\aaa'
- *  to = 'C:\\orandea\\impl\\bbb'
- * The output of the function should be: '..\\..\\impl\\bbb'
- *
- * @example Usage
- * ```ts
- * import { relative } from "@std/path/windows/relative";
- * import { assertEquals } from "@std/assert";
- *
- * const relativePath = relative("C:\\foobar\\test\\aaa", "C:\\foobar\\impl\\bbb");
- * assertEquals(relativePath, "..\\..\\impl\\bbb");
- * ```
- *
- * @param from The path from which to calculate the relative path
- * @param to The path to which to calculate the relative path
- * @returns The relative path from `from` to `to`
- */
-export function relative(from: string, to: string): string {
-  assertArgs(from, to);
-
-  const fromOrig = resolve(from);
-  const toOrig = resolve(to);
-
-  if (fromOrig === toOrig) return "";
-
-  from = fromOrig.toLowerCase();
-  to = toOrig.toLowerCase();
-
-  if (from === to) return "";
-
-  // Trim any leading backslashes
-  let fromStart = 0;
-  let fromEnd = from.length;
-  for (; fromStart < fromEnd; ++fromStart) {
-    if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break;
-  }
-  // Trim trailing backslashes (applicable to UNC paths only)
-  for (; fromEnd - 1 > fromStart; --fromEnd) {
-    if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break;
-  }
-  const fromLen = fromEnd - fromStart;
-
-  // Trim any leading backslashes
-  let toStart = 0;
-  let toEnd = to.length;
-  for (; toStart < toEnd; ++toStart) {
-    if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break;
-  }
-  // Trim trailing backslashes (applicable to UNC paths only)
-  for (; toEnd - 1 > toStart; --toEnd) {
-    if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break;
-  }
-  const toLen = toEnd - toStart;
-
-  // Compare paths to find the longest common path from root
-  const length = fromLen < toLen ? fromLen : toLen;
-  let lastCommonSep = -1;
-  let i = 0;
-  for (; i <= length; ++i) {
-    if (i === length) {
-      if (toLen > length) {
-        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
-          // We get here if `from` is the exact base path for `to`.
-          // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz'
-          return toOrig.slice(toStart + i + 1);
-        } else if (i === 2) {
-          // We get here if `from` is the device root.
-          // For example: from='C:\\'; to='C:\\foo'
-          return toOrig.slice(toStart + i);
-        }
-      }
-      if (fromLen > length) {
-        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
-          // We get here if `to` is the exact base path for `from`.
-          // For example: from='C:\\foo\\bar'; to='C:\\foo'
-          lastCommonSep = i;
-        } else if (i === 2) {
-          // We get here if `to` is the device root.
-          // For example: from='C:\\foo\\bar'; to='C:\\'
-          lastCommonSep = 3;
-        }
-      }
-      break;
-    }
-    const fromCode = from.charCodeAt(fromStart + i);
-    const toCode = to.charCodeAt(toStart + i);
-    if (fromCode !== toCode) break;
-    else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i;
-  }
-
-  // We found a mismatch before the first common path separator was seen, so
-  // return the original `to`.
-  if (i !== length && lastCommonSep === -1) {
-    return toOrig;
-  }
-
-  let out = "";
-  if (lastCommonSep === -1) lastCommonSep = 0;
-  // Generate the relative path based on the path difference between `to` and
-  // `from`
-  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-    if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
-      if (out.length === 0) out += "..";
-      else out += "\\..";
-    }
-  }
-
-  // Lastly, append the rest of the destination (`to`) path that comes after
-  // the common path parts
-  if (out.length > 0) {
-    return out + toOrig.slice(toStart + lastCommonSep, toEnd);
-  } else {
-    toStart += lastCommonSep;
-    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart;
-    return toOrig.slice(toStart, toEnd);
-  }
-}

package/src/deps/jsr.io/@std/path/1.0.8/windows/resolve.ts

@@ -1,178 +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";
-
-
-import { CHAR_COLON } from "../_common/constants.js";
-import { normalizeString } from "../_common/normalize_string.js";
-import { assertPath } from "../_common/assert_path.js";
-import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
-
-/**
- * Resolves path segments into a `path`.
- *
- * @example Usage
- * ```ts
- * import { resolve } from "@std/path/windows/resolve";
- * import { assertEquals } from "@std/assert";
- *
- * const resolved = resolve("C:\\foo\\bar", "..\\baz");
- * assertEquals(resolved, "C:\\foo\\baz");
- * ```
- *
- * @param pathSegments The path segments to process to path
- * @returns The resolved path
- */
-export function resolve(...pathSegments: string[]): string {
-  let resolvedDevice = "";
-  let resolvedTail = "";
-  let resolvedAbsolute = false;
-
-  for (let i = pathSegments.length - 1; i >= -1; i--) {
-    let path: string;
-    // deno-lint-ignore no-explicit-any
-    const { Deno } = dntShim.dntGlobalThis as any;
-    if (i >= 0) {
-      path = pathSegments[i]!;
-    } else if (!resolvedDevice) {
-      if (typeof Deno?.cwd !== "function") {
-        throw new TypeError(
-          "Resolved a drive-letter-less path without a current working directory (CWD)",
-        );
-      }
-      path = Deno.cwd();
-    } else {
-      if (
-        typeof Deno?.env?.get !== "function" || typeof Deno?.cwd !== "function"
-      ) {
-        throw new TypeError(
-          "Resolved a relative path without a current working directory (CWD)",
-        );
-      }
-      path = Deno.cwd();
-
-      // Verify that a cwd was found and that it actually points
-      // to our drive. If not, default to the drive's root.
-      if (
-        path === undefined ||
-        path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`
-      ) {
-        path = `${resolvedDevice}\\`;
-      }
-    }
-
-    assertPath(path);
-
-    const len = path.length;
-
-    // Skip empty entries
-    if (len === 0) continue;
-
-    let rootEnd = 0;
-    let device = "";
-    let isAbsolute = false;
-    const code = path.charCodeAt(0);
-
-    // Try to match a root
-    if (len > 1) {
-      if (isPathSeparator(code)) {
-        // Possible UNC root
-
-        // If we started with a separator, we know we at least have an
-        // absolute path of some kind (UNC or otherwise)
-        isAbsolute = true;
-
-        if (isPathSeparator(path.charCodeAt(1))) {
-          // Matched double path separator at beginning
-          let j = 2;
-          let last = j;
-          // Match 1 or more non-path separators
-          for (; j < len; ++j) {
-            if (isPathSeparator(path.charCodeAt(j))) break;
-          }
-          if (j < len && j !== last) {
-            const firstPart = path.slice(last, j);
-            // Matched!
-            last = j;
-            // Match 1 or more path separators
-            for (; j < len; ++j) {
-              if (!isPathSeparator(path.charCodeAt(j))) break;
-            }
-            if (j < len && j !== last) {
-              // Matched!
-              last = j;
-              // Match 1 or more non-path separators
-              for (; j < len; ++j) {
-                if (isPathSeparator(path.charCodeAt(j))) break;
-              }
-              if (j === len) {
-                // We matched a UNC root only
-                device = `\\\\${firstPart}\\${path.slice(last)}`;
-                rootEnd = j;
-              } else if (j !== last) {
-                // We matched a UNC root with leftovers
-
-                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
-                rootEnd = j;
-              }
-            }
-          }
-        } else {
-          rootEnd = 1;
-        }
-      } else if (isWindowsDeviceRoot(code)) {
-        // Possible device root
-
-        if (path.charCodeAt(1) === CHAR_COLON) {
-          device = path.slice(0, 2);
-          rootEnd = 2;
-          if (len > 2) {
-            if (isPathSeparator(path.charCodeAt(2))) {
-              // Treat separator following drive name as an absolute path
-              // indicator
-              isAbsolute = true;
-              rootEnd = 3;
-            }
-          }
-        }
-      }
-    } else if (isPathSeparator(code)) {
-      // `path` contains just a path separator
-      rootEnd = 1;
-      isAbsolute = true;
-    }
-
-    if (
-      device.length > 0 &&
-      resolvedDevice.length > 0 &&
-      device.toLowerCase() !== resolvedDevice.toLowerCase()
-    ) {
-      // This path points to another device so it is not applicable
-      continue;
-    }
-
-    if (resolvedDevice.length === 0 && device.length > 0) {
-      resolvedDevice = device;
-    }
-    if (!resolvedAbsolute) {
-      resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
-      resolvedAbsolute = isAbsolute;
-    }
-
-    if (resolvedAbsolute && resolvedDevice.length > 0) break;
-  }
-
-  // At this point the path should be resolved to a full absolute path,
-  // but handle relative paths to be safe (might happen when Deno.cwd()
-  // fails)
-
-  // Normalize the tail path
-  resolvedTail = normalizeString(
-    resolvedTail,
-    !resolvedAbsolute,
-    "\\",
-    isPathSeparator,
-  );
-
-  return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || ".";
-}

package/src/deps/jsr.io/@std/path/1.0.8/windows/to_file_url.ts

@@ -1,38 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { encodeWhitespace } from "../_common/to_file_url.js";
-import { isAbsolute } from "./is_absolute.js";
-
-/**
- * Converts a path string to a file URL.
- *
- * @example Usage
- * ```ts
- * import { toFileUrl } from "@std/path/windows/to-file-url";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
- * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
- * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
- * ```
- * @param path The path to convert.
- * @returns The file URL.
- */
-export function toFileUrl(path: string): URL {
-  if (!isAbsolute(path)) {
-    throw new TypeError(`Path must be absolute: received "${path}"`);
-  }
-  const [, hostname, pathname] = path.match(
-    /^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/,
-  )!;
-  const url = new URL("file:///");
-  url.pathname = encodeWhitespace(pathname!.replace(/%/g, "%25"));
-  if (hostname !== undefined && hostname !== "localhost") {
-    url.hostname = hostname;
-    if (!url.hostname) {
-      throw new TypeError(`Invalid hostname: "${url.hostname}"`);
-    }
-  }
-  return url;
-}

package/src/deps/jsr.io/@std/path/1.0.8/windows/to_namespaced_path.ts

@@ -1,60 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import {
-  CHAR_BACKWARD_SLASH,
-  CHAR_COLON,
-  CHAR_DOT,
-  CHAR_QUESTION_MARK,
-} from "../_common/constants.js";
-import { isWindowsDeviceRoot } from "./_util.js";
-import { resolve } from "./resolve.js";
-
-/**
- * Resolves path to a namespace path
- *
- * @example Usage
- * ```ts
- * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
- * import { assertEquals } from "@std/assert";
- *
- * const namespaced = toNamespacedPath("C:\\foo\\bar");
- * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
- * ```
- *
- * @param path The path to resolve to namespaced path
- * @returns The resolved namespaced path
- */
-export function toNamespacedPath(path: string): string {
-  // Note: this will *probably* throw somewhere.
-  if (typeof path !== "string") return path;
-  if (path.length === 0) return "";
-
-  const resolvedPath = resolve(path);
-
-  if (resolvedPath.length >= 3) {
-    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
-      // Possible UNC root
-
-      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
-        const code = resolvedPath.charCodeAt(2);
-        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
-          // Matched non-long UNC root, convert the path to a long UNC path
-          return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
-        }
-      }
-    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
-      // Possible device root
-
-      if (
-        resolvedPath.charCodeAt(1) === CHAR_COLON &&
-        resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH
-      ) {
-        // Matched device root, convert the path to a long UNC path
-        return `\\\\?\\${resolvedPath}`;
-      }
-    }
-  }
-
-  return path;
-}

package/src/literal.ts

@@ -1,10 +0,0 @@
-import { make, type Ty } from "./_base.js"
-
-export function literal<V extends number | string>(description: string | undefined, value: V): LiteralTy<V> {
-  return make<LiteralTy<V>>(() => ({
-    const: value,
-    description,
-  }))
-}
-
-export type LiteralTy<V extends number | string = any> = Ty<V>