structured-outputs 0.1.0-beta.1 → 0.1.0-beta.10

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

@@ -0,0 +1,102 @@
+// 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

@@ -0,0 +1,79 @@
+// 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

@@ -0,0 +1,14 @@
+// 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

@@ -0,0 +1,251 @@
+// 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

@@ -0,0 +1,113 @@
+// 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

@@ -0,0 +1,47 @@
+// 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

@@ -0,0 +1,47 @@
+// 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

@@ -0,0 +1,25 @@
+// 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;
+}