@goast/core 0.4.0-beta4 → 0.4.1

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

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

@@ -0,0 +1,18 @@
+// 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/_test_suite.ts

@@ -0,0 +1,448 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import * as dntShim from "../../../../../_dnt.test_shims.js";
+
+
+import { getAssertionState } from "../../internal/1.0.5/assertion_state.js";
+import { AssertionError } from "../../assert/1.0.11/assertion_error.js";
+
+export const globalSanitizersState = {
+  sanitizeExit: undefined as boolean | undefined,
+  sanitizeOps: undefined as boolean | undefined,
+  sanitizeResources: undefined as boolean | undefined,
+};
+const assertionState = getAssertionState();
+
+/** The options for creating a test suite with the describe function. */
+export interface DescribeDefinition<T> extends Omit<dntShim.Deno.TestDefinition, "fn"> {
+  /** The body of the test suite */
+  fn?: () => void | undefined;
+  /**
+   * The `describe` function returns a `TestSuite` representing the group of tests.
+   * If `describe` is called within another `describe` calls `fn`, the suite will default to that parent `describe` calls returned `TestSuite`.
+   * If `describe` is not called within another `describe` calls `fn`, the suite will default to the `TestSuite` representing the global group of tests.
+   */
+  suite?: TestSuite<T>;
+  /** Run some shared setup before all of the tests in the suite. */
+  beforeAll?:
+    | ((this: T) => void | Promise<void>)
+    | ((this: T) => void | Promise<void>)[];
+  /** Run some shared teardown after all of the tests in the suite. */
+  afterAll?:
+    | ((this: T) => void | Promise<void>)
+    | ((this: T) => void | Promise<void>)[];
+  /** Run some shared setup before each test in the suite. */
+  beforeEach?:
+    | ((this: T) => void | Promise<void>)
+    | ((this: T) => void | Promise<void>)[];
+  /** Run some shared teardown after each test in the suite. */
+  afterEach?:
+    | ((this: T) => void | Promise<void>)
+    | ((this: T) => void | Promise<void>)[];
+}
+
+/** The options for creating an individual test case with the it function. */
+export interface ItDefinition<T> extends Omit<dntShim.Deno.TestDefinition, "fn"> {
+  /** The body of the test case */
+  fn: (this: T, t: dntShim.Deno.TestContext) => void | Promise<void>;
+  /**
+   * The `describe` function returns a `TestSuite` representing the group of tests.
+   * If `it` is called within a `describe` calls `fn`, the suite will default to that parent `describe` calls returned `TestSuite`.
+   * If `it` is not called within a `describe` calls `fn`, the suite will default to the `TestSuite` representing the global group of tests.
+   */
+  suite?: TestSuite<T>;
+}
+
+/** The names of all the different types of hooks. */
+export type HookNames = "beforeAll" | "afterAll" | "beforeEach" | "afterEach";
+
+/**
+ * A group of tests.
+ */
+export interface TestSuite<T> {
+  /** The symbol to use for grouping the test suite */
+  symbol: symbol;
+}
+
+/**
+ * An internal representation of a group of tests.
+ */
+export class TestSuiteInternal<T> implements TestSuite<T> {
+  symbol: symbol;
+  protected describe: DescribeDefinition<T>;
+  protected steps: (TestSuiteInternal<T> | ItDefinition<T>)[];
+  protected hasOnlyStep: boolean;
+
+  constructor(describe: DescribeDefinition<T>) {
+    this.describe = describe;
+    this.steps = [];
+    this.hasOnlyStep = false;
+
+    const { suite } = describe;
+    if (suite && !TestSuiteInternal.suites.has(suite.symbol)) {
+      throw new Error(
+        "Cannot construct Test Suite: suite does not represent a registered test suite",
+      );
+    }
+    const testSuite = suite
+      ? TestSuiteInternal.suites.get(suite.symbol)
+      : TestSuiteInternal.current;
+    this.symbol = Symbol();
+    TestSuiteInternal.suites.set(this.symbol, this);
+
+    const { fn, ignore } = describe;
+    if (ignore) {
+      const {
+        name,
+        only,
+        permissions,
+        sanitizeExit = globalSanitizersState.sanitizeExit,
+        sanitizeOps = globalSanitizersState.sanitizeOps,
+        sanitizeResources = globalSanitizersState.sanitizeResources,
+      } = describe;
+      const options: dntShim.Deno.TestDefinition = {
+        name,
+        fn: async () => {},
+        ignore: true,
+      };
+      if (only !== undefined) {
+        options.only = only;
+      }
+      if (permissions !== undefined) {
+        options.permissions = permissions;
+      }
+      if (sanitizeExit !== undefined) {
+        options.sanitizeExit = sanitizeExit;
+      }
+      if (sanitizeOps !== undefined) {
+        options.sanitizeOps = sanitizeOps;
+      }
+      if (sanitizeResources !== undefined) {
+        options.sanitizeResources = sanitizeResources;
+      }
+      TestSuiteInternal.registerTest(options);
+      return;
+    }
+
+    if (fn) {
+      const temp = TestSuiteInternal.current;
+      TestSuiteInternal.current = this;
+      try {
+        // deno-lint-ignore no-explicit-any
+        const value = fn() as any;
+        if (value instanceof Promise) {
+          throw new Error(
+            'Returning a Promise from "describe" is not supported: tests must be defined synchronously',
+          );
+        }
+      } finally {
+        TestSuiteInternal.current = temp;
+      }
+    }
+
+    if (testSuite) {
+      TestSuiteInternal.addStep(testSuite, this);
+    } else {
+      const {
+        name,
+        ignore,
+        permissions,
+        sanitizeExit = globalSanitizersState.sanitizeExit,
+        sanitizeOps = globalSanitizersState.sanitizeOps,
+        sanitizeResources = globalSanitizersState.sanitizeResources,
+      } = describe;
+      let { only } = describe;
+      if (!ignore && this.hasOnlyStep) {
+        only = true;
+      }
+      const options: dntShim.Deno.TestDefinition = {
+        name,
+        fn: async (t) => {
+          TestSuiteInternal.runningCount++;
+          try {
+            const context = {} as T;
+            const { beforeAll } = this.describe;
+            if (typeof beforeAll === "function") {
+              await beforeAll.call(context);
+            } else if (beforeAll) {
+              for (const hook of beforeAll) {
+                await hook.call(context);
+              }
+            }
+            try {
+              TestSuiteInternal.active.push(this.symbol);
+              await TestSuiteInternal.run(this, context, t);
+            } finally {
+              TestSuiteInternal.active.pop();
+              const { afterAll } = this.describe;
+              if (typeof afterAll === "function") {
+                await afterAll.call(context);
+              } else if (afterAll) {
+                for (const hook of afterAll) {
+                  await hook.call(context);
+                }
+              }
+            }
+          } finally {
+            TestSuiteInternal.runningCount--;
+          }
+        },
+      };
+      if (ignore !== undefined) {
+        options.ignore = ignore;
+      }
+      if (only !== undefined) {
+        options.only = only;
+      }
+      if (permissions !== undefined) {
+        options.permissions = permissions;
+      }
+      if (sanitizeExit !== undefined) {
+        options.sanitizeExit = sanitizeExit;
+      }
+      if (sanitizeOps !== undefined) {
+        options.sanitizeOps = sanitizeOps;
+      }
+      if (sanitizeResources !== undefined) {
+        options.sanitizeResources = sanitizeResources;
+      }
+      TestSuiteInternal.registerTest(options);
+    }
+  }
+
+  /** Stores how many test suites are executing. */
+  static runningCount = 0;
+
+  /** If a test has been registered yet. Block adding global hooks if a test has been registered. */
+  static started = false;
+
+  /** A map of all test suites by symbol. */
+  // deno-lint-ignore no-explicit-any
+  static suites = new Map<symbol, TestSuiteInternal<any>>();
+
+  /** The current test suite being registered. */
+  // deno-lint-ignore no-explicit-any
+  static current: TestSuiteInternal<any> | null = null;
+
+  /** The stack of tests that are actively running. */
+  static active: symbol[] = [];
+
+  /** This is used internally for testing this module. */
+  static reset() {
+    TestSuiteInternal.runningCount = 0;
+    TestSuiteInternal.started = false;
+    TestSuiteInternal.current = null;
+    TestSuiteInternal.active = [];
+  }
+
+  /** This is used internally to register tests. */
+  static registerTest(options: dntShim.Deno.TestDefinition) {
+    options = { ...options };
+    if (options.only === undefined) {
+      delete options.only;
+    }
+    if (options.permissions === undefined) {
+      delete options.permissions;
+    }
+    if (options.ignore === undefined) {
+      delete options.ignore;
+    }
+    if (options.sanitizeExit === undefined) {
+      delete options.sanitizeExit;
+    }
+    if (options.sanitizeOps === undefined) {
+      delete options.sanitizeOps;
+    }
+    if (options.sanitizeResources === undefined) {
+      delete options.sanitizeResources;
+    }
+    dntShim.Deno.test(options);
+  }
+
+  /** Updates all steps within top level suite to have ignore set to true if only is not set to true on step. */
+  static addingOnlyStep<T>(suite: TestSuiteInternal<T>) {
+    if (!suite.hasOnlyStep) {
+      for (let i = 0; i < suite.steps.length; i++) {
+        const step = suite.steps[i]!;
+        if (!(step instanceof TestSuiteInternal) && !step.only) {
+          suite.steps.splice(i--, 1);
+        }
+      }
+      suite.hasOnlyStep = true;
+    }
+
+    const parentSuite = suite.describe.suite;
+    const parentTestSuite = parentSuite &&
+      TestSuiteInternal.suites.get(parentSuite.symbol);
+    if (parentTestSuite) {
+      TestSuiteInternal.addingOnlyStep(parentTestSuite);
+    }
+  }
+
+  /** This is used internally to add steps to a test suite. */
+  static addStep<T>(
+    suite: TestSuiteInternal<T>,
+    step: TestSuiteInternal<T> | ItDefinition<T>,
+  ) {
+    if (!suite.hasOnlyStep) {
+      if (step instanceof TestSuiteInternal) {
+        if (step.hasOnlyStep || step.describe.only) {
+          TestSuiteInternal.addingOnlyStep(suite);
+        }
+      } else {
+        if (step.only) TestSuiteInternal.addingOnlyStep(suite);
+      }
+    }
+
+    if (
+      !(suite.hasOnlyStep && !(step instanceof TestSuiteInternal) && !step.only)
+    ) {
+      suite.steps.push(step);
+    }
+  }
+
+  /** This is used internally to add hooks to a test suite. */
+  static setHook<T>(
+    suite: TestSuiteInternal<T>,
+    name: HookNames,
+    fn: (this: T) => void | Promise<void>,
+  ) {
+    if (suite.describe[name]) {
+      if (typeof suite.describe[name] === "function") {
+        suite.describe[name] = [
+          suite.describe[name] as ((this: T) => void | Promise<void>),
+        ];
+      }
+      (suite.describe[name] as ((this: T) => void | Promise<void>)[]).push(fn);
+    } else {
+      suite.describe[name] = fn;
+    }
+  }
+
+  /** This is used internally to run all steps for a test suite. */
+  static async run<T>(
+    suite: TestSuiteInternal<T>,
+    context: T,
+    t: dntShim.Deno.TestContext,
+  ) {
+    const hasOnly = suite.hasOnlyStep || suite.describe.only || false;
+    for (const step of suite.steps) {
+      if (
+        hasOnly && step instanceof TestSuiteInternal &&
+        !(step.hasOnlyStep || step.describe.only || false)
+      ) {
+        continue;
+      }
+
+      const {
+        name,
+        fn,
+        ignore,
+        permissions,
+        sanitizeExit = globalSanitizersState.sanitizeExit,
+        sanitizeOps = globalSanitizersState.sanitizeOps,
+        sanitizeResources = globalSanitizersState.sanitizeResources,
+      } = step instanceof TestSuiteInternal ? step.describe : step;
+
+      const options: dntShim.Deno.TestStepDefinition = {
+        name,
+        fn: async (t) => {
+          if (permissions) {
+            throw new Error(
+              "permissions option not available for nested tests",
+            );
+          }
+          context = { ...context };
+          if (step instanceof TestSuiteInternal) {
+            const { beforeAll } = step.describe;
+            if (typeof beforeAll === "function") {
+              await beforeAll.call(context);
+            } else if (beforeAll) {
+              for (const hook of beforeAll) {
+                await hook.call(context);
+              }
+            }
+            try {
+              TestSuiteInternal.active.push(step.symbol);
+              await TestSuiteInternal.run(step, context, t);
+            } finally {
+              TestSuiteInternal.active.pop();
+              const { afterAll } = step.describe;
+              if (typeof afterAll === "function") {
+                await afterAll.call(context);
+              } else if (afterAll) {
+                for (const hook of afterAll) {
+                  await hook.call(context);
+                }
+              }
+            }
+          } else {
+            await TestSuiteInternal.runTest(t, fn!, context);
+          }
+        },
+      };
+      if (ignore !== undefined) {
+        options.ignore = ignore;
+      }
+      if (sanitizeExit !== undefined) {
+        options.sanitizeExit = sanitizeExit;
+      }
+      if (sanitizeOps !== undefined) {
+        options.sanitizeOps = sanitizeOps;
+      }
+      if (sanitizeResources !== undefined) {
+        options.sanitizeResources = sanitizeResources;
+      }
+      await t.step(options);
+    }
+  }
+
+  static async runTest<T>(
+    t: dntShim.Deno.TestContext,
+    fn: (this: T, t: dntShim.Deno.TestContext) => void | Promise<void>,
+    context: T,
+    activeIndex = 0,
+  ) {
+    const suite = TestSuiteInternal.active[activeIndex];
+    const testSuite = suite && TestSuiteInternal.suites.get(suite);
+    if (testSuite) {
+      if (activeIndex === 0) context = { ...context };
+      const { beforeEach } = testSuite.describe;
+      if (typeof beforeEach === "function") {
+        await beforeEach.call(context);
+      } else if (beforeEach) {
+        for (const hook of beforeEach) {
+          await hook.call(context);
+        }
+      }
+      try {
+        await TestSuiteInternal.runTest(t, fn, context, activeIndex + 1);
+      } finally {
+        const { afterEach } = testSuite.describe;
+        if (typeof afterEach === "function") {
+          await afterEach.call(context);
+        } else if (afterEach) {
+          for (const hook of afterEach) {
+            await hook.call(context);
+          }
+        }
+      }
+    } else {
+      await fn.call(context, t);
+    }
+
+    if (assertionState.checkAssertionErrorState()) {
+      throw new AssertionError(
+        "Expected at least one assertion to be called but received none",
+      );
+    }
+
+    if (assertionState.checkAssertionCountSatisfied()) {
+      throw new AssertionError(
+        `Expected at least ${assertionState.assertionCount} assertion to be called, ` +
+          `but received ${assertionState.assertionTriggeredCount}`,
+      );
+    }
+
+    assertionState.resetAssertionState();
+  }
+}