veryfront 0.1.324 → 0.1.327

package/src/deps/jsr.io/@std/internal/1.0.13/diff_str.ts

@@ -0,0 +1,208 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import type { ChangedDiffResult, DiffResult } from "./types.js";
+import { diff } from "./diff.js";
+
+/**
+ * Unescape invisible characters.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#escape_sequences}
+ *
+ * @param string String to unescape.
+ *
+ * @returns Unescaped string.
+ *
+ * @example Usage
+ * ```ts
+ * import { unescape } from "@std/internal/diff-str";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(unescape("Hello\nWorld"), "Hello\\n\nWorld");
+ * ```
+ */
+export function unescape(string: string): string {
+  return string
+    .replaceAll("\\", "\\\\")
+    .replaceAll("\b", "\\b")
+    .replaceAll("\f", "\\f")
+    .replaceAll("\t", "\\t")
+    .replaceAll("\v", "\\v")
+    // This does not remove line breaks
+    .replaceAll(
+      /\r\n|\r|\n/g,
+      (str) => str === "\r" ? "\\r" : str === "\n" ? "\\n\n" : "\\r\\n\r\n",
+    );
+}
+
+const WHITESPACE_SYMBOLS_REGEXP =
+  /((?:\\[bftv]|[^\S\r\n])+|\\[rn\\]|[()[\]{}'"\r\n]|\b)/;
+
+/**
+ * Tokenizes a string into an array of tokens.
+ *
+ * @param string The string to tokenize.
+ * @param wordDiff If true, performs word-based tokenization. Default is false.
+ *
+ * @returns An array of tokens.
+ *
+ * @example Usage
+ * ```ts
+ * import { tokenize } from "@std/internal/diff-str";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(tokenize("Hello\nWorld"), ["Hello\n", "World"]);
+ * ```
+ */
+export function tokenize(string: string, wordDiff = false): string[] {
+  if (wordDiff) {
+    return string
+      .split(WHITESPACE_SYMBOLS_REGEXP)
+      .filter((token) => token);
+  }
+  const tokens: string[] = [];
+  const lines = string.split(/(\n|\r\n)/).filter((line) => line);
+
+  for (const [i, line] of lines.entries()) {
+    if (i % 2) {
+      tokens[tokens.length - 1] += line;
+    } else {
+      tokens.push(line);
+    }
+  }
+  return tokens;
+}
+
+/**
+ * Create details by filtering relevant word-diff for current line and merge
+ * "space-diff" if surrounded by word-diff for cleaner displays.
+ *
+ * @param line Current line
+ * @param tokens Word-diff tokens
+ *
+ * @returns Array of diff results.
+ *
+ * @example Usage
+ * ```ts
+ * import { createDetails } from "@std/internal/diff-str";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const tokens = [
+ *   { type: "added", value: "a" },
+ *   { type: "removed", value: "b" },
+ *   { type: "common", value: "c" },
+ * ] as const;
+ * assertEquals(
+ *   createDetails({ type: "added", value: "a" }, [...tokens]),
+ *   [{ type: "added", value: "a" }, { type: "common", value: "c" }]
+ * );
+ * ```
+ */
+export function createDetails(
+  line: DiffResult<string>,
+  tokens: DiffResult<string>[],
+): DiffResult<string>[] {
+  return tokens.filter(({ type }) => type === line.type || type === "common")
+    .map((result, i, t) => {
+      const token = t[i - 1];
+      if (
+        (result.type === "common") && token &&
+        (token.type === t[i + 1]?.type) && /\s+/.test(result.value)
+      ) {
+        return {
+          ...result,
+          type: token.type,
+        };
+      }
+      return result;
+    });
+}
+
+const NON_WHITESPACE_REGEXP = /\S/;
+
+/**
+ * Renders the differences between the actual and expected strings. Partially
+ * inspired from {@link https://github.com/kpdecker/jsdiff}.
+ *
+ * @param A Actual string
+ * @param B Expected string
+ *
+ * @returns Array of diff results.
+ *
+ * @example Usage
+ * ```ts
+ * import { diffStr } from "@std/internal/diff-str";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(diffStr("Hello!", "Hello"), [
+ *   {
+ *     type: "removed",
+ *     value: "Hello!\n",
+ *     details: [
+ *       { type: "common", value: "Hello" },
+ *       { type: "removed", value: "!" },
+ *       { type: "common", value: "\n" }
+ *     ]
+ *   },
+ *   {
+ *     type: "added",
+ *     value: "Hello\n",
+ *     details: [
+ *       { type: "common", value: "Hello" },
+ *       { type: "common", value: "\n" }
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+export function diffStr(A: string, B: string): DiffResult<string>[] {
+  // Compute multi-line diff
+  const diffResult = diff(
+    tokenize(`${unescape(A)}\n`),
+    tokenize(`${unescape(B)}\n`),
+  );
+
+  const added = [];
+  const removed = [];
+  for (const result of diffResult) {
+    if (result.type === "added") {
+      added.push(result);
+    }
+    if (result.type === "removed") {
+      removed.push(result);
+    }
+  }
+
+  // Compute word-diff
+  const hasMoreRemovedLines = added.length < removed.length;
+  const aLines = hasMoreRemovedLines ? added : removed;
+  const bLines = hasMoreRemovedLines ? removed : added;
+  for (const a of aLines) {
+    let tokens = [] as Array<DiffResult<string>>;
+    let b: undefined | ChangedDiffResult<string>;
+    // Search another diff line with at least one common token
+    while (bLines.length) {
+      b = bLines.shift();
+      const tokenized = [
+        tokenize(a.value, true),
+        tokenize(b!.value, true),
+      ] as [string[], string[]];
+      if (hasMoreRemovedLines) tokenized.reverse();
+      tokens = diff(tokenized[0], tokenized[1]);
+      if (
+        tokens.some(({ type, value }) =>
+          type === "common" && NON_WHITESPACE_REGEXP.test(value)
+        )
+      ) {
+        break;
+      }
+    }
+    // Register word-diff details
+    a.details = createDetails(a, tokens);
+    if (b) {
+      b.details = createDetails(b, tokens);
+    }
+  }
+
+  return diffResult;
+}

package/src/deps/jsr.io/@std/internal/1.0.13/format.ts

@@ -0,0 +1,89 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/** An inspect function conforming to the shape of `Deno.inspect` and `node:util`'s `inspect` */
+import * as dntShim from "../../../../../_dnt.shims.js";
+
+export type InspectFn = (
+  v: unknown,
+  options: {
+    depth: number;
+    sorted: boolean;
+    trailingComma: boolean;
+    compact: boolean;
+    iterableLimit: number;
+    getters: boolean;
+    strAbbreviateSize: number;
+  },
+) => string;
+
+/**
+ * Converts the input into a string. Objects, Sets and Maps are sorted so as to
+ * make tests less flaky.
+ *
+ * @param v Value to be formatted
+ *
+ * @returns The formatted string
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/internal/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(format({ a: 1, b: 2 }), "{\n  a: 1,\n  b: 2,\n}");
+ * assertEquals(format(new Set([1, 2])), "Set(2) {\n  1,\n  2,\n}");
+ * assertEquals(format(new Map([[1, 2]])), "Map(1) {\n  1 => 2,\n}");
+ * ```
+ */
+export function format(v: unknown): string {
+  // deno-lint-ignore no-explicit-any
+  const { Deno, process } = dntShim.dntGlobalThis as any;
+
+  const inspect: InspectFn | undefined = Deno?.inspect ??
+    process?.getBuiltinModule?.("node:util")?.inspect;
+
+  return typeof inspect === "function"
+    ? inspect(v, {
+      depth: Infinity,
+      sorted: true,
+      trailingComma: true,
+      compact: false,
+      iterableLimit: Infinity,
+      // getters should be true in assertEquals.
+      getters: true,
+      strAbbreviateSize: Infinity,
+    })
+    : basicInspect(v);
+}
+
+const formatters: ((v: unknown) => string | undefined)[] = [
+  (v) => {
+    if (typeof v === "undefined") return "undefined";
+    if (typeof v === "bigint") return `${v}n`;
+
+    if (
+      typeof v === "string" ||
+      typeof v === "number" ||
+      typeof v === "boolean" ||
+      v === null ||
+      Array.isArray(v) ||
+      [null, Object.prototype].includes(Object.getPrototypeOf(v))
+    ) {
+      return JSON.stringify(v, null, 2);
+    }
+  },
+  (v) => String(v),
+  (v) => Object.prototype.toString.call(v),
+];
+
+// for environments lacking both `Deno.inspect` and `process.inspect`
+function basicInspect(v: unknown): string {
+  for (const fmt of formatters) {
+    try {
+      const result = fmt(v);
+      if (typeof result === "string") return result;
+    } catch { /* try the next one */ }
+  }
+
+  return "[[Unable to format value]]";
+}

package/src/deps/jsr.io/@std/internal/1.0.13/styles.ts

@@ -0,0 +1,233 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+// A module to print ANSI terminal colors. Inspired by chalk, kleur, and colors
+// on npm.
+
+// This code is vendored from `fmt/colors.ts`.
+
+// deno-lint-ignore no-explicit-any
+import * as dntShim from "../../../../../_dnt.shims.js";
+
+const { Deno } = dntShim.dntGlobalThis as any;
+const noColor = typeof Deno?.noColor === "boolean"
+  ? Deno.noColor as boolean
+  : false;
+
+interface Code {
+  open: string;
+  close: string;
+  regexp: RegExp;
+}
+
+const enabled = !noColor;
+
+function code(open: number[], close: number): Code {
+  return {
+    open: `\x1b[${open.join(";")}m`,
+    close: `\x1b[${close}m`,
+    regexp: new RegExp(`\\x1b\\[${close}m`, "g"),
+  };
+}
+
+function run(str: string, code: Code): string {
+  return enabled
+    ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}`
+    : str;
+}
+
+/**
+ * Sets the style of text to be printed to bold.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make bold
+ *
+ * @returns Bold text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bold } from "@std/internal/styles";
+ *
+ * console.log(bold("Hello, world!")); // Prints "Hello, world!" in bold
+ * ```
+ */
+export function bold(str: string): string {
+  return run(str, code([1], 22));
+}
+
+/**
+ * Sets the color of text to be printed to red.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make red
+ *
+ * @returns Red text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red } from "@std/internal/styles";
+ *
+ * console.log(red("Hello, world!")); // Prints "Hello, world!" in red
+ * ```
+ */
+export function red(str: string): string {
+  return run(str, code([31], 39));
+}
+
+/**
+ * Sets the color of text to be printed to green.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make green
+ *
+ * @returns Green text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { green } from "@std/internal/styles";
+ *
+ * console.log(green("Hello, world!")); // Prints "Hello, world!" in green
+ * ```
+ */
+export function green(str: string): string {
+  return run(str, code([32], 39));
+}
+
+/**
+ * Sets the color of text to be printed to yellow.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make yellow
+ *
+ * @returns Yellow text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { yellow } from "@std/internal/styles";
+ *
+ * console.log(yellow("Hello, world!")); // Prints "Hello, world!" in yellow
+ * ```
+ */
+export function yellow(str: string): string {
+  return run(str, code([33], 39));
+}
+
+/**
+ * Sets the color of text to be printed to white.
+ *
+ * @param str Text to make white
+ *
+ * @returns White text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { white } from "@std/internal/styles";
+ *
+ * console.log(white("Hello, world!")); // Prints "Hello, world!" in white
+ * ```
+ */
+export function white(str: string): string {
+  return run(str, code([37], 39));
+}
+
+/**
+ * Sets the color of text to be printed to gray.
+ *
+ * @param str Text to make gray
+ *
+ * @returns Gray text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { gray } from "@std/internal/styles";
+ *
+ * console.log(gray("Hello, world!")); // Prints "Hello, world!" in gray
+ * ```
+ */
+export function gray(str: string): string {
+  return brightBlack(str);
+}
+
+/**
+ * Sets the color of text to be printed to bright-black.
+ *
+ * @param str Text to make bright-black
+ *
+ * @returns Bright-black text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { brightBlack } from "@std/internal/styles";
+ *
+ * console.log(brightBlack("Hello, world!")); // Prints "Hello, world!" in bright-black
+ * ```
+ */
+export function brightBlack(str: string): string {
+  return run(str, code([90], 39));
+}
+
+/**
+ * Sets the background color of text to be printed to red.
+ *
+ * @param str Text to make its background red
+ *
+ * @returns Red background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgRed } from "@std/internal/styles";
+ *
+ * console.log(bgRed("Hello, world!")); // Prints "Hello, world!" with red background
+ * ```
+ */
+export function bgRed(str: string): string {
+  return run(str, code([41], 49));
+}
+
+/**
+ * Sets the background color of text to be printed to green.
+ *
+ * @param str Text to make its background green
+ *
+ * @returns Green background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgGreen } from "@std/internal/styles";
+ *
+ * console.log(bgGreen("Hello, world!")); // Prints "Hello, world!" with green background
+ * ```
+ */
+export function bgGreen(str: string): string {
+  return run(str, code([42], 49));
+}
+
+// https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
+const ANSI_REGEXP = new RegExp(
+  [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
+  ].join("|"),
+  "g",
+);
+
+/**
+ * Remove ANSI escape codes from the string.
+ *
+ * @param string Text to remove ANSI escape codes from
+ *
+ * @returns Text without ANSI escape codes
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red, stripAnsiCode } from "@std/internal/styles";
+ *
+ * console.log(stripAnsiCode(red("Hello, world!"))); // Prints "Hello, world!"
+ * ```
+ */
+export function stripAnsiCode(string: string): string {
+  return string.replace(ANSI_REGEXP, "");
+}

package/src/deps/jsr.io/@std/internal/1.0.13/types.ts

@@ -0,0 +1,30 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/** Ways that lines in a diff can be different. */
+export type DiffType = DiffResult<unknown>["type"];
+
+/**
+ * Represents the result of a diff operation.
+ * @typeParam T The type of the value in the diff result.
+ */
+export type DiffResult<T> = ChangedDiffResult<T> | CommonDiffResult<T>;
+
+/**
+ * Represents the result of a common diff operation.
+ * @typeParam T The type of the value in the diff result.
+ */
+export type CommonDiffResult<T> = {
+  type: "common" | "truncation";
+  value: T;
+};
+
+/**
+ * Represents the result of a changed diff operation.
+ * @typeParam T The type of the value in the diff result.
+ */
+export type ChangedDiffResult<T> = {
+  type: "removed" | "added";
+  value: T;
+  details?: DiffResult<T>[];
+};