@goast/kotlin 0.4.14 → 0.4.16-beta1

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

@@ -1,204 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import type { 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("\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 = /([^\S\r\n]+|[()[\]{}'"\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)
-      .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 | DiffResult<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.5/format.ts

@@ -1,39 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-
-/**
- * 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}");
- * ```
- */
-import * as dntShim from "../../../../../_dnt.test_shims.js";
-
-export function format(v: unknown): string {
-  // deno-lint-ignore no-explicit-any
-  const { Deno } = dntShim.dntGlobalThis as any;
-  return typeof Deno?.inspect === "function"
-    ? Deno.inspect(v, {
-      depth: Infinity,
-      sorted: true,
-      trailingComma: true,
-      compact: false,
-      iterableLimit: Infinity,
-      // getters should be true in assertEquals.
-      getters: true,
-      strAbbreviateSize: Infinity,
-    })
-    : `"${String(v).replace(/(?=["\\])/g, "\\")}"`;
-}

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

@@ -1,233 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. 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.test_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_PATTERN = 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_PATTERN, "");
-}

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

@@ -1,18 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-
-/** Ways that lines in a diff can be different. */
-export type DiffType = "removed" | "common" | "added";
-
-/**
- * Represents the result of a diff operation.
- *
- * @typeParam T The type of the value in the diff result.
- */
-export interface DiffResult<T> {
-  /** The type of the diff. */
-  type: DiffType;
-  /** The value of the diff. */
-  value: T;
-  /** The details of the diff. */
-  details?: DiffResult<T>[];
-}

package/src/deps/jsr.io/@std/testing/1.0.9/_mock_utils.ts

@@ -1,43 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-import type { Spy } from "./mock.js";
-
-/**
- * Checks if a function is a spy.
- *
- * @typeParam Self The self type of the function.
- * @typeParam Args The arguments type of the function.
- * @typeParam Return The return type of the function.
- * @param func The function to check
- * @return `true` if the function is a spy, `false` otherwise.
- */
-export function isSpy<Self, Args extends unknown[], Return>(
-  func: ((this: Self, ...args: Args) => Return) | unknown,
-): func is Spy<Self, Args, Return> {
-  const spy = func as Spy<Self, Args, Return>;
-  return typeof spy === "function" &&
-    typeof spy.original === "function" &&
-    typeof spy.restored === "boolean" &&
-    typeof spy.restore === "function" &&
-    Array.isArray(spy.calls);
-}
-
-// deno-lint-ignore no-explicit-any
-export const sessions: Set<Spy<any, any[], any>>[] = [];
-
-// deno-lint-ignore no-explicit-any
-function getSession(): Set<Spy<any, any[], any>> {
-  if (sessions.length === 0) sessions.push(new Set());
-  return sessions.at(-1)!;
-}
-
-// deno-lint-ignore no-explicit-any
-export function registerMock(spy: Spy<any, any[], any>) {
-  const session = getSession();
-  session.add(spy);
-}
-
-// deno-lint-ignore no-explicit-any
-export function unregisterMock(spy: Spy<any, any[], any>) {
-  const session = getSession();
-  session.delete(spy);
-}