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

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

@@ -1,117 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { assertArg } from "../_common/dirname.js";
-import { CHAR_COLON } from "../_common/constants.js";
-import { stripTrailingSeparators } from "../_common/strip_trailing_separators.js";
-import {
-  isPathSeparator,
-  isPosixPathSeparator,
-  isWindowsDeviceRoot,
-} from "./_util.js";
-
-/**
- * Return the directory path of a `path`.
- *
- * @example Usage
- * ```ts
- * import { dirname } from "@std/path/windows/dirname";
- * import { assertEquals } from "@std/assert";
- *
- * const dir = dirname("C:\\foo\\bar\\baz.ext");
- * assertEquals(dir, "C:\\foo\\bar");
- * ```
- *
- * Note: If you are working with file URLs,
- * use the new version of `dirname` from `@std/path/windows/unstable-dirname`.
- *
- * @param path The path to get the directory from.
- * @returns The directory path.
- */
-export function dirname(path: string): string {
-  assertArg(path);
-
-  const len = path.length;
-  let rootEnd = -1;
-  let end = -1;
-  let matchedSlash = true;
-  let offset = 0;
-  const code = path.charCodeAt(0);
-
-  // Try to match a root
-  if (len > 1) {
-    if (isPathSeparator(code)) {
-      // Possible UNC root
-
-      rootEnd = offset = 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
-              return path;
-            }
-            if (j !== last) {
-              // We matched a UNC root with leftovers
-
-              // Offset by 1 to include the separator after the UNC root to
-              // treat it as a "normal root" on top of a (UNC) root
-              rootEnd = offset = j + 1;
-            }
-          }
-        }
-      }
-    } else if (isWindowsDeviceRoot(code)) {
-      // Possible device root
-
-      if (path.charCodeAt(1) === CHAR_COLON) {
-        rootEnd = offset = 2;
-        if (len > 2) {
-          if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;
-        }
-      }
-    }
-  } else if (isPathSeparator(code)) {
-    // `path` contains just a path separator, exit early to avoid
-    // unnecessary work
-    return path;
-  }
-
-  for (let i = len - 1; i >= offset; --i) {
-    if (isPathSeparator(path.charCodeAt(i))) {
-      if (!matchedSlash) {
-        end = i;
-        break;
-      }
-    } else {
-      // We saw the first non-path separator
-      matchedSlash = false;
-    }
-  }
-
-  if (end === -1) {
-    if (rootEnd === -1) return ".";
-    else end = rootEnd;
-  }
-  return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
-}

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

@@ -1,89 +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 { assertPath } from "../_common/assert_path.js";
-import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
-
-/**
- * Return the extension of the `path` with leading period.
- *
- * @example Usage
- * ```ts
- * import { extname } from "@std/path/windows/extname";
- * import { assertEquals } from "@std/assert";
- *
- * const ext = extname("file.ts");
- * assertEquals(ext, ".ts");
- * ```
- *
- * Note: If you are working with file URLs,
- * use the new version of `extname` from `@std/path/windows/unstable-extname`.
- *
- * @param path The path to get the extension from.
- * @returns The extension of the `path`.
- */
-export function extname(path: string): string {
-  assertPath(path);
-
-  let start = 0;
-  let startDot = -1;
-  let startPart = 0;
-  let end = -1;
-  let matchedSlash = true;
-  // Track the state of characters (if any) we see before our first dot and
-  // after any path separator we find
-  let preDotState = 0;
-
-  // Check for a drive letter prefix so as not to mistake the following
-  // path separator as an extra separator at the end of the path that can be
-  // disregarded
-
-  if (
-    path.length >= 2 &&
-    path.charCodeAt(1) === CHAR_COLON &&
-    isWindowsDeviceRoot(path.charCodeAt(0))
-  ) {
-    start = startPart = 2;
-  }
-
-  for (let i = path.length - 1; i >= start; --i) {
-    const 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)
-  ) {
-    return "";
-  }
-  return path.slice(startDot, end);
-}

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

@@ -1,31 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { _format, assertArg } from "../_common/format.js";
-import type { ParsedPath } from "../types.js";
-
-/**
- * Generate a path from `ParsedPath` object.
- *
- * @example Usage
- * ```ts
- * import { format } from "@std/path/windows/format";
- * import { assertEquals } from "@std/assert";
- *
- * const path = format({
- *   root: "C:\\",
- *   dir: "C:\\path\\dir",
- *   base: "file.txt",
- *   ext: ".txt",
- *   name: "file"
- * });
- * assertEquals(path, "C:\\path\\dir\\file.txt");
- * ```
- *
- * @param pathObject The path object to format.
- * @returns The formatted path.
- */
-export function format(pathObject: Partial<ParsedPath>): string {
-  assertArg(pathObject);
-  return _format("\\", pathObject);
-}

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

@@ -1,34 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { assertArg } from "../_common/from_file_url.js";
-
-/**
- * Converts a file URL to a path string.
- *
- * @example Usage
- * ```ts
- * import { fromFileUrl } from "@std/path/windows/from-file-url";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(fromFileUrl("file:///home/foo"), "\\home\\foo");
- * assertEquals(fromFileUrl("file:///C:/Users/foo"), "C:\\Users\\foo");
- * assertEquals(fromFileUrl("file://localhost/home/foo"), "\\home\\foo");
- * ```
- *
- * @param url The file URL to convert.
- * @returns The path string.
- */
-export function fromFileUrl(url: URL | string): string {
-  url = assertArg(url);
-  let path = decodeURIComponent(
-    url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25"),
-  ).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
-  if (url.hostname !== "") {
-    // Note: The `URL` implementation guarantees that the drive letter and
-    // hostname are mutually exclusive. Otherwise it would not have been valid
-    // to append the hostname and path like this.
-    path = `\\\\${url.hostname}${path}`;
-  }
-  return path;
-}

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

@@ -1,92 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import {
-  _globToRegExp,
-  type GlobConstants,
-  type GlobOptions,
-} from "../_common/glob_to_reg_exp.js";
-
-const constants: GlobConstants = {
-  sep: "(?:\\\\|/)+",
-  sepMaybe: "(?:\\\\|/)*",
-  seps: ["\\", "/"],
-  globstar: "(?:[^\\\\/]*(?:\\\\|/|$)+)*",
-  wildcard: "[^\\\\/]*",
-  escapePrefix: "`",
-};
-
-/** Convert a glob string to a regular expression.
- *
- * Tries to match bash glob expansion as closely as possible.
- *
- * Basic glob syntax:
- * - `*` - Matches everything without leaving the path segment.
- * - `?` - Matches any single character.
- * - `{foo,bar}` - Matches `foo` or `bar`.
- * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
- * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
- * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
- * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
- *     - `[[:alnum:]]` - Matches any digit or letter.
- *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
- *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
- *       for a complete list of supported character classes.
- * - `\` - Escapes the next character for an `os` other than `"windows"`.
- * - \` - Escapes the next character for `os` set to `"windows"`.
- * - `/` - Path separator.
- * - `\` - Additional path separator only for `os` set to `"windows"`.
- *
- * Extended syntax:
- * - Requires `{ extended: true }`.
- * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
- * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
- * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
- * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
- * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
- * - See https://www.linuxjournal.com/content/bash-extended-globbing.
- *
- * Globstar syntax:
- * - Requires `{ globstar: true }`.
- * - `**` - Matches any number of any path segments.
- *     - Must comprise its entire path segment in the provided glob.
- * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
- *
- * Note the following properties:
- * - The generated `RegExp` is anchored at both start and end.
- * - Repeating and trailing separators are tolerated. Trailing separators in the
- *   provided glob have no meaning and are discarded.
- * - Absolute globs will only match absolute paths, etc.
- * - Empty globs will match nothing.
- * - Any special glob syntax must be contained to one path segment. For example,
- *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the
- *   first segment ends with an unclosed group.
- * - If a path segment ends with unclosed groups or a dangling escape prefix, a
- *   parse error has occurred. Every character for that segment is taken
- *   literally in this event.
- *
- * Limitations:
- * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
- *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
- *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
- *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
- *   the group occurs not nested at the end of the segment.
- *
- * @example Usage
- * ```ts
- * import { globToRegExp } from "@std/path/windows/glob-to-regexp";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(globToRegExp("*.js"), /^[^\\/]*\.js(?:\\|\/)*$/);
- * ```
- *
- * @param glob Glob string to convert.
- * @param options Conversion options.
- * @returns The regular expression equivalent to the glob.
- */
-export function globToRegExp(
-  glob: string,
-  options: GlobOptions = {},
-): RegExp {
-  return _globToRegExp(constants, glob, options);
-}

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

@@ -1,40 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { CHAR_COLON } from "../_common/constants.js";
-import { assertPath } from "../_common/assert_path.js";
-import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
-
-/**
- * Verifies whether provided path is absolute.
- *
- * @example Usage
- * ```ts
- * import { isAbsolute } from "@std/path/windows/is-absolute";
- * import { assert, assertFalse } from "@std/assert";
- *
- * assert(isAbsolute("C:\\foo\\bar"));
- * assertFalse(isAbsolute("..\\baz"));
- * ```
- *
- * @param path The path to verify.
- * @returns `true` if the path is absolute, `false` otherwise.
- */
-export function isAbsolute(path: string): boolean {
-  assertPath(path);
-
-  const len = path.length;
-  if (len === 0) return false;
-
-  const code = path.charCodeAt(0);
-  if (isPathSeparator(code)) {
-    return true;
-  } else if (isWindowsDeviceRoot(code)) {
-    // Possible device root
-
-    if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {
-      if (isPathSeparator(path.charCodeAt(2))) return true;
-    }
-  }
-  return false;
-}

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

@@ -1,75 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { assertPath } from "../_common/assert_path.js";
-import { isPathSeparator } from "./_util.js";
-import { normalize } from "./normalize.js";
-
-/**
- * Join all given a sequence of `paths`,then normalizes the resulting path.
- *
- * @example Usage
- * ```ts
- * import { join } from "@std/path/windows/join";
- * import { assertEquals } from "@std/assert";
- *
- * const joined = join("C:\\foo", "bar", "baz\\..");
- * assertEquals(joined, "C:\\foo\\bar");
- * ```
- *
- * Note: If you are working with file URLs,
- * use the new version of `join` from `@std/path/windows/unstable-join`.
- *
- * @param paths The paths to join.
- * @returns The joined path.
- */
-export function join(...paths: string[]): string {
-  paths.forEach((path) => assertPath(path));
-  paths = paths.filter((path) => path.length > 0);
-  if (paths.length === 0) return ".";
-
-  // Make sure that the joined path doesn't start with two slashes, because
-  // normalize() will mistake it for an UNC path then.
-  //
-  // This step is skipped when it is very clear that the user actually
-  // intended to point at an UNC path. This is assumed when the first
-  // non-empty string arguments starts with exactly two slashes followed by
-  // at least one more non-slash character.
-  //
-  // Note that for normalize() to treat a path as an UNC path it needs to
-  // have at least 2 components, so we don't filter for that here.
-  // This means that the user can use join to construct UNC paths from
-  // a server name and a share name; for example:
-  //   path.join('//server', 'share') -> '\\\\server\\share\\'
-  let needsReplace = true;
-  let slashCount = 0;
-  const firstPart = paths[0]!;
-  if (isPathSeparator(firstPart.charCodeAt(0))) {
-    ++slashCount;
-    const firstLen = firstPart.length;
-    if (firstLen > 1) {
-      if (isPathSeparator(firstPart.charCodeAt(1))) {
-        ++slashCount;
-        if (firstLen > 2) {
-          if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;
-          else {
-            // We matched a UNC path in the first part
-            needsReplace = false;
-          }
-        }
-      }
-    }
-  }
-  let joined = paths.join("\\");
-  if (needsReplace) {
-    // Find any more consecutive slashes we need to replace
-    for (; slashCount < joined.length; ++slashCount) {
-      if (!isPathSeparator(joined.charCodeAt(slashCount))) break;
-    }
-
-    // Replace the slashes if needed
-    if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`;
-  }
-
-  return normalize(joined);
-}

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

@@ -1,46 +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 { join } from "./join.js";
-import { SEPARATOR } from "./constants.js";
-import { normalizeGlob } from "./normalize_glob.js";
-
-export type { GlobOptions };
-
-/**
- * Like join(), but doesn't collapse "**\/.." when `globstar` is true.
- *
- * @example Usage
- *
- * ```ts
- * import { joinGlobs } from "@std/path/windows/join-globs";
- * import { assertEquals } from "@std/assert";
- *
- * const joined = joinGlobs(["foo", "**", "bar"], { globstar: true });
- * assertEquals(joined, "foo\\**\\bar");
- * ```
- *
- * @param globs The globs to join.
- * @param options The options for glob pattern.
- * @returns The joined glob pattern.
- */
-export function joinGlobs(
-  globs: string[],
-  options: Pick<GlobOptions, "globstar"> = {},
-): string {
-  const { globstar = false } = options;
-  if (!globstar || globs.length === 0) {
-    return join(...globs);
-  }
-  let joined: string | undefined;
-  for (const glob of globs) {
-    const path = glob;
-    if (path.length > 0) {
-      if (!joined) joined = path;
-      else joined += `${SEPARATOR}${path}`;
-    }
-  }
-  if (!joined) return ".";
-  return normalizeGlob(joined, { globstar });
-}

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

@@ -1,135 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-import { assertArg } from "../_common/normalize.js";
-import { CHAR_COLON } from "../_common/constants.js";
-import { normalizeString } from "../_common/normalize_string.js";
-import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
-
-/**
- * Normalize the `path`, resolving `'..'` and `'.'` segments.
- * Note that resolving these segments does not necessarily mean that all will be eliminated.
- * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
- *
- * @example Usage
- * ```ts
- * import { normalize } from "@std/path/windows/normalize";
- * import { assertEquals } from "@std/assert";
- *
- * const normalized = normalize("C:\\foo\\..\\bar");
- * assertEquals(normalized, "C:\\bar");
- * ```
- *
- * Note: If you are working with file URLs,
- * use the new version of `normalize` from `@std/path/windows/unstable-normalize`.
- *
- * @param path The path to normalize
- * @returns The normalized path
- */
-export function normalize(path: string): string {
-  assertArg(path);
-
-  const len = path.length;
-  let rootEnd = 0;
-  let device: string | undefined;
-  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
-              // Return the normalized version of the UNC root since there
-              // is nothing left to process
-
-              return `\\\\${firstPart}\\${path.slice(last)}\\`;
-            } 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, exit early to avoid unnecessary
-    // work
-    return "\\";
-  }
-
-  let tail: string;
-  if (rootEnd < len) {
-    tail = normalizeString(
-      path.slice(rootEnd),
-      !isAbsolute,
-      "\\",
-      isPathSeparator,
-    );
-  } else {
-    tail = "";
-  }
-  if (tail.length === 0 && !isAbsolute) tail = ".";
-  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {
-    tail += "\\";
-  }
-  if (device === undefined) {
-    if (isAbsolute) {
-      if (tail.length > 0) return `\\${tail}`;
-      else return "\\";
-    }
-    return tail;
-  } else if (isAbsolute) {
-    if (tail.length > 0) return `${device}\\${tail}`;
-    else return `${device}\\`;
-  }
-  return device + tail;
-}