@goast/core 0.4.0-beta4 → 0.4.1

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

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

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

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

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

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

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

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

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