@goast/core 0.4.1 → 0.5.0-beta.1

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/_test_suite.ts

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