@goast/typescript 0.4.4 → 0.5.1-k6.1

package/src/deps/jsr.io/@std/assert/1.0.11/rejects.ts

@@ -1,123 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-import { assertIsError } from "./is_error.js";
-
-/**
- * Executes a function which returns a promise, expecting it to reject.
- *
- * To assert that a synchronous function throws, use {@linkcode assertThrows}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertRejects } from "@std/assert";
- *
- * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
- * await assertRejects(async () => console.log("Hello world")); // Throws
- * ```
- *
- * @param fn The function to execute.
- * @param msg The optional message to display if the assertion fails.
- * @returns The promise which resolves to the thrown error.
- */
-export function assertRejects(
-  fn: () => PromiseLike<unknown>,
-  msg?: string,
-): Promise<unknown>;
-/**
- * Executes a function which returns a promise, expecting it to reject.
- * If it does not, then it throws. An error class and a string that should be
- * included in the error message can also be asserted.
- *
- * To assert that a synchronous function throws, use {@linkcode assertThrows}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertRejects } from "@std/assert";
- *
- * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
- * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
- * ```
- *
- * @typeParam E The error class to assert.
- * @param fn The function to execute.
- * @param ErrorClass The error class to assert.
- * @param msgIncludes The string that should be included in the error message.
- * @param msg The optional message to display if the assertion fails.
- * @returns The promise which resolves to the thrown error.
- */
-export function assertRejects<E extends Error = Error>(
-  fn: () => PromiseLike<unknown>,
-  // deno-lint-ignore no-explicit-any
-  ErrorClass: abstract new (...args: any[]) => E,
-  msgIncludes?: string,
-  msg?: string,
-): Promise<E>;
-export async function assertRejects<E extends Error = Error>(
-  fn: () => PromiseLike<unknown>,
-  errorClassOrMsg?:
-    // deno-lint-ignore no-explicit-any
-    | (abstract new (...args: any[]) => E)
-    | string,
-  msgIncludesOrMsg?: string,
-  msg?: string,
-): Promise<E | Error | unknown> {
-  // deno-lint-ignore no-explicit-any
-  let ErrorClass: (abstract new (...args: any[]) => E) | undefined;
-  let msgIncludes: string | undefined;
-  let err;
-
-  if (typeof errorClassOrMsg !== "string") {
-    if (
-      errorClassOrMsg === undefined ||
-      errorClassOrMsg.prototype instanceof Error ||
-      errorClassOrMsg.prototype === Error.prototype
-    ) {
-      ErrorClass = errorClassOrMsg;
-      msgIncludes = msgIncludesOrMsg;
-    }
-  } else {
-    msg = errorClassOrMsg;
-  }
-  let doesThrow = false;
-  let isPromiseReturned = false;
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  try {
-    const possiblePromise = fn();
-    if (
-      possiblePromise &&
-      typeof possiblePromise === "object" &&
-      typeof possiblePromise.then === "function"
-    ) {
-      isPromiseReturned = true;
-      await possiblePromise;
-    } else {
-      throw new Error();
-    }
-  } catch (error) {
-    if (!isPromiseReturned) {
-      throw new AssertionError(
-        `Function throws when expected to reject${msgSuffix}`,
-      );
-    }
-    if (ErrorClass) {
-      if (!(error instanceof Error)) {
-        throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
-      }
-      assertIsError(
-        error,
-        ErrorClass,
-        msgIncludes,
-        msg,
-      );
-    }
-    err = error;
-    doesThrow = true;
-  }
-  if (!doesThrow) {
-    throw new AssertionError(
-      `Expected function to reject${msgSuffix}`,
-    );
-  }
-  return err;
-}

package/src/deps/jsr.io/@std/assert/1.0.11/strict_equals.ts

@@ -1,67 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { buildMessage } from "../../internal/1.0.5/build_message.js";
-import { diff } from "../../internal/1.0.5/diff.js";
-import { diffStr } from "../../internal/1.0.5/diff_str.js";
-import { format } from "../../internal/1.0.5/format.js";
-import { red } from "../../internal/1.0.5/styles.js";
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` and `expected` are strictly equal, using
- * {@linkcode Object.is} for equality comparison. If not, then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertStrictEquals } from "@std/assert";
- *
- * const a = {};
- * const b = a;
- * assertStrictEquals(a, b); // Doesn't throw
- *
- * const c = {};
- * const d = {};
- * assertStrictEquals(c, d); // Throws
- * ```
- *
- * @typeParam T The type of the expected value.
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertStrictEquals<T>(
-  actual: unknown,
-  expected: T,
-  msg?: string,
-): asserts actual is T {
-  if (Object.is(actual, expected)) {
-    return;
-  }
-
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  let message: string;
-
-  const actualString = format(actual);
-  const expectedString = format(expected);
-
-  if (actualString === expectedString) {
-    const withOffset = actualString
-      .split("\n")
-      .map((l) => `    ${l}`)
-      .join("\n");
-    message =
-      `Values have the same structure but are not reference-equal${msgSuffix}\n\n${
-        red(withOffset)
-      }\n`;
-  } else {
-    const stringDiff = (typeof actual === "string") &&
-      (typeof expected === "string");
-    const diffResult = stringDiff
-      ? diffStr(actual as string, expected as string)
-      : diff(actualString.split("\n"), expectedString.split("\n"));
-    const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
-    message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
-  }
-
-  throw new AssertionError(message);
-}

package/src/deps/jsr.io/@std/expect/1.0.12/_assert_equals.ts

@@ -1,38 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-
-// This file is copied from `std/assert`.
-
-import { AssertionError } from "../../assert/1.0.11/assertion_error.js";
-import { buildEqualErrorMessage } from "./_build_message.js";
-import { equal } from "./_equal.js";
-import type { EqualOptions } from "./_types.js";
-
-/**
- * Make an assertion that `actual` and `expected` are equal, deeply. If not
- * deeply equal, then throw.
- *
- * Type parameter can be specified to ensure values under comparison have the
- * same type.
- *
- * @example
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals("world", "world"); // Doesn't throw
- * assertEquals("hello", "world"); // Throws
- * ```
- *
- * Note: formatter option is experimental and may be removed in the future.
- */
-export function assertEquals<T>(
-  actual: T,
-  expected: T,
-  options?: EqualOptions,
-) {
-  if (equal(actual, expected, options)) {
-    return;
-  }
-
-  const message = buildEqualErrorMessage(actual, expected, options ?? {});
-  throw new AssertionError(message);
-}

package/src/deps/jsr.io/@std/expect/1.0.12/_assert_is_error.ts

@@ -1,54 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "../../assert/1.0.11/assertion_error.js";
-import { stripAnsiCode } from "../../internal/1.0.5/styles.js";
-
-/**
- * Make an assertion that `error` is an `Error`.
- * If not then an error will be thrown.
- * An error class and a string that should be included in the
- * error message can also be asserted.
- *
- * @typeParam E The type of the error to assert.
- * @param error The error to assert.
- * @param ErrorClass The optional error class to assert.
- * @param msgMatches The optional string or RegExp to assert in the error message.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertIsError<E extends Error = Error>(
-  error: unknown,
-  // deno-lint-ignore no-explicit-any
-  ErrorClass?: abstract new (...args: any[]) => E,
-  msgMatches?: string | RegExp,
-  msg?: string,
-): asserts error is E {
-  const msgPrefix = msg ? `${msg}: ` : "";
-  if (!(error instanceof Error)) {
-    throw new AssertionError(
-      `${msgPrefix}Expected "error" to be an Error object.`,
-    );
-  }
-  if (ErrorClass && !(error instanceof ErrorClass)) {
-    msg =
-      `${msgPrefix}Expected error to be instance of "${ErrorClass.name}", but was "${error?.constructor?.name}".`;
-    throw new AssertionError(msg);
-  }
-  let msgCheck;
-  if (typeof msgMatches === "string") {
-    msgCheck = stripAnsiCode(error.message).includes(
-      stripAnsiCode(msgMatches),
-    );
-  }
-  if (msgMatches instanceof RegExp) {
-    msgCheck = msgMatches.test(stripAnsiCode(error.message));
-  }
-
-  if (msgMatches && !msgCheck) {
-    msg = `${msgPrefix}Expected error message to include ${
-      msgMatches instanceof RegExp
-        ? msgMatches.toString()
-        : JSON.stringify(msgMatches)
-    }, but got ${JSON.stringify(error?.message)}.`;
-    throw new AssertionError(msg);
-  }
-}

package/src/deps/jsr.io/@std/expect/1.0.12/_assert_not_equals.ts

@@ -1,35 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-
-// This file is copied from `std/assert`.
-
-import { AssertionError } from "../../assert/1.0.11/assertion_error.js";
-import { buildNotEqualErrorMessage } from "./_build_message.js";
-import { equal } from "./_equal.js";
-import type { EqualOptions } from "./_types.js";
-
-/**
- * Make an assertion that `actual` and `expected` are not equal, deeply.
- * If not then throw.
- *
- * Type parameter can be specified to ensure values under comparison have the same type.
- *
- * @example
- * ```ts ignore
- * import { assertNotEquals } from "@std/assert";
- *
- * assertNotEquals(1, 2); // Doesn't throw
- * assertNotEquals(1, 1); // Throws
- * ```
- */
-export function assertNotEquals<T>(
-  actual: T,
-  expected: T,
-  options: EqualOptions = {},
-) {
-  if (!equal(actual, expected, options)) {
-    return;
-  }
-
-  const message = buildNotEqualErrorMessage(actual, expected, options ?? {});
-  throw new AssertionError(message);
-}

package/src/deps/jsr.io/@std/expect/1.0.12/_assertions.ts

@@ -1,18 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-
-import { getAssertionState } from "../../internal/1.0.5/assertion_state.js";
-
-const assertionState = getAssertionState();
-
-export function hasAssertions() {
-  assertionState.setAssertionCheck(true);
-}
-
-export function assertions(num: number) {
-  assertionState.setAssertionCount(num);
-}
-
-export function emitAssertionTrigger() {
-  assertionState.setAssertionTriggered(true);
-  assertionState.updateAssertionTriggerCount();
-}

package/src/deps/jsr.io/@std/expect/1.0.12/_asymmetric_matchers.ts

@@ -1,198 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// deno-lint-ignore-file no-explicit-any
-
-import { getCustomEqualityTesters } from "./_custom_equality_tester.js";
-import { equal } from "./_equal.js";
-
-export abstract class AsymmetricMatcher<T> {
-  constructor(
-    protected value: T,
-    protected inverse: boolean = false,
-  ) {}
-  abstract equals(other: unknown): boolean;
-}
-
-export class Anything extends AsymmetricMatcher<void> {
-  equals(other: unknown): boolean {
-    return other !== null && other !== undefined;
-  }
-}
-
-export function anything(): Anything {
-  return new Anything();
-}
-
-export class Any extends AsymmetricMatcher<any> {
-  constructor(value: unknown) {
-    if (value === undefined) {
-      throw new TypeError("Expected a constructor function");
-    }
-    super(value);
-  }
-
-  equals(other: unknown): boolean {
-    if (typeof other === "object") {
-      return other instanceof this.value;
-    } else {
-      if (this.value === Number) {
-        return typeof other === "number";
-      }
-
-      if (this.value === String) {
-        return typeof other === "string";
-      }
-
-      if (this.value === Number) {
-        return typeof other === "number";
-      }
-
-      if (this.value === Function) {
-        return typeof other === "function";
-      }
-
-      if (this.value === Boolean) {
-        return typeof other === "boolean";
-      }
-
-      if (this.value === BigInt) {
-        return typeof other === "bigint";
-      }
-
-      if (this.value === Symbol) {
-        return typeof other === "symbol";
-      }
-    }
-    return false;
-  }
-}
-
-export function any(c: unknown): Any {
-  return new Any(c);
-}
-
-export class ArrayContaining extends AsymmetricMatcher<any[]> {
-  constructor(arr: any[], inverse = false) {
-    super(arr, inverse);
-  }
-
-  equals(other: any[]): boolean {
-    const res = Array.isArray(other) &&
-      this.value.every((e) =>
-        other.some((another) =>
-          equal(e, another, { customTesters: getCustomEqualityTesters() })
-        )
-      );
-    return this.inverse ? !res : res;
-  }
-}
-
-export function arrayContaining(c: any[]): ArrayContaining {
-  return new ArrayContaining(c);
-}
-
-export function arrayNotContaining(c: any[]): ArrayContaining {
-  return new ArrayContaining(c, true);
-}
-
-export class CloseTo extends AsymmetricMatcher<number> {
-  readonly #precision: number;
-
-  constructor(num: number, precision: number = 2) {
-    super(num);
-    this.#precision = precision;
-  }
-
-  equals(other: number): boolean {
-    if (typeof other !== "number") {
-      return false;
-    }
-
-    if (
-      (this.value === Number.POSITIVE_INFINITY &&
-        other === Number.POSITIVE_INFINITY) ||
-      (this.value === Number.NEGATIVE_INFINITY &&
-        other === Number.NEGATIVE_INFINITY)
-    ) {
-      return true;
-    }
-
-    return Math.abs(this.value - other) < Math.pow(10, -this.#precision) / 2;
-  }
-}
-
-export function closeTo(num: number, numDigits?: number): CloseTo {
-  return new CloseTo(num, numDigits);
-}
-
-export class StringContaining extends AsymmetricMatcher<string> {
-  constructor(str: string, inverse = false) {
-    super(str, inverse);
-  }
-
-  equals(other: string): boolean {
-    const res = typeof other !== "string" ? false : other.includes(this.value);
-    return this.inverse ? !res : res;
-  }
-}
-
-export function stringContaining(str: string): StringContaining {
-  return new StringContaining(str);
-}
-
-export function stringNotContaining(str: string): StringContaining {
-  return new StringContaining(str, true);
-}
-
-export class StringMatching extends AsymmetricMatcher<RegExp> {
-  constructor(pattern: string | RegExp, inverse = false) {
-    super(new RegExp(pattern), inverse);
-  }
-
-  equals(other: string): boolean {
-    const res = typeof other !== "string" ? false : this.value.test(other);
-    return this.inverse ? !res : res;
-  }
-}
-
-export function stringMatching(pattern: string | RegExp): StringMatching {
-  return new StringMatching(pattern);
-}
-
-export function stringNotMatching(pattern: string | RegExp): StringMatching {
-  return new StringMatching(pattern, true);
-}
-
-export class ObjectContaining
-  extends AsymmetricMatcher<Record<string, unknown>> {
-  constructor(obj: Record<string, unknown>, inverse = false) {
-    super(obj, inverse);
-  }
-
-  equals(other: Record<string, unknown>): boolean {
-    const keys = Object.keys(this.value);
-    let res = true;
-
-    for (const key of keys) {
-      if (
-        !Object.hasOwn(other, key) ||
-        !equal(this.value[key], other[key])
-      ) {
-        res = false;
-      }
-    }
-
-    return this.inverse ? !res : res;
-  }
-}
-
-export function objectContaining(
-  obj: Record<string, unknown>,
-): ObjectContaining {
-  return new ObjectContaining(obj);
-}
-
-export function objectNotContaining(
-  obj: Record<string, unknown>,
-): ObjectContaining {
-  return new ObjectContaining(obj, true);
-}

package/src/deps/jsr.io/@std/expect/1.0.12/_build_message.ts

@@ -1,51 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-
-import { buildMessage } from "../../internal/1.0.5/build_message.js";
-import { diff } from "../../internal/1.0.5/diff.js";
-import { diffStr } from "../../internal/1.0.5/diff_str.js";
-import { format } from "../../internal/1.0.5/format.js";
-import type { EqualOptions } from "./_types.js";
-
-type EqualErrorMessageOptions = Pick<
-  EqualOptions,
-  "formatter" | "msg"
->;
-
-function isString(value: unknown): value is string {
-  return typeof value === "string";
-}
-
-export function buildEqualErrorMessage<T>(
-  actual: T,
-  expected: T,
-  options: EqualErrorMessageOptions,
-): string {
-  const { formatter = format, msg } = options ?? {};
-  const msgPrefix = msg ? `${msg}: ` : "";
-  const actualString = formatter(actual);
-  const expectedString = formatter(expected);
-
-  let message = `${msgPrefix}Values are not equal.`;
-
-  const stringDiff = isString(actual) && isString(expected);
-  const diffResult = stringDiff
-    ? diffStr(actual, expected)
-    : diff(actualString.split("\n"), expectedString.split("\n"));
-  const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
-  message = `${message}\n${diffMsg}`;
-
-  return message;
-}
-
-export function buildNotEqualErrorMessage<T>(
-  actual: T,
-  expected: T,
-  options: EqualErrorMessageOptions,
-): string {
-  const { msg } = options ?? {};
-  const actualString = String(actual);
-  const expectedString = String(expected);
-
-  const msgPrefix = msg ? `${msg}: ` : "";
-  return `${msgPrefix}Expected actual: ${actualString} not to be: ${expectedString}.`;
-}

package/src/deps/jsr.io/@std/expect/1.0.12/_custom_equality_tester.ts

@@ -1,19 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-
-import type { Tester } from "./_types.js";
-
-const customEqualityTesters: Tester[] = [];
-
-export function addCustomEqualityTesters(newTesters: Tester[]) {
-  if (!Array.isArray(newTesters)) {
-    throw new TypeError(
-      `customEqualityTester expects an array of Testers. But got ${typeof newTesters}`,
-    );
-  }
-
-  customEqualityTesters.push(...newTesters);
-}
-
-export function getCustomEqualityTesters() {
-  return customEqualityTesters;
-}