@goast/core 0.4.0-beta4 → 0.4.1

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

@@ -0,0 +1,24 @@
+/**
+ * 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 declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+//# sourceMappingURL=strict_equals.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.11/strict_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/strict_equals.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,CAAC,CA+BrB"}

package/esm/deps/jsr.io/@std/assert/1.0.11/strict_equals.js

@@ -0,0 +1,57 @@
+// 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(actual, expected, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message;
+    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, expected)
+            : 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/esm/deps/jsr.io/@std/expect/1.0.12/_assert_equals.d.ts

@@ -0,0 +1,20 @@
+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 declare function assertEquals<T>(actual: T, expected: T, options?: EqualOptions): void;
+//# sourceMappingURL=_assert_equals.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.12/_assert_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.12/_assert_equals.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,OAAO,CAAC,EAAE,YAAY,QAQvB"}

package/esm/deps/jsr.io/@std/expect/1.0.12/_assert_equals.js

@@ -0,0 +1,29 @@
+// 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";
+/**
+ * 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(actual, expected, options) {
+    if (equal(actual, expected, options)) {
+        return;
+    }
+    const message = buildEqualErrorMessage(actual, expected, options !== null && options !== void 0 ? options : {});
+    throw new AssertionError(message);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * 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 declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: abstract new (...args: any[]) => E, msgMatches?: string | RegExp, msg?: string): asserts error is E;
+//# sourceMappingURL=_assert_is_error.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.12/_assert_is_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert_is_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.12/_assert_is_error.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EACnD,KAAK,EAAE,OAAO,EAEd,UAAU,CAAC,EAAE,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAC/C,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAC5B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,KAAK,IAAI,CAAC,CA8BpB"}

package/esm/deps/jsr.io/@std/expect/1.0.12/_assert_is_error.js

@@ -0,0 +1,43 @@
+// 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(error, 
+// deno-lint-ignore no-explicit-any
+ErrorClass, msgMatches, msg) {
+    var _a;
+    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 "${(_a = error === null || error === void 0 ? void 0 : error.constructor) === null || _a === void 0 ? void 0 : _a.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 === null || error === void 0 ? void 0 : error.message)}.`;
+        throw new AssertionError(msg);
+    }
+}

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

@@ -0,0 +1,17 @@
+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 declare function assertNotEquals<T>(actual: T, expected: T, options?: EqualOptions): void;
+//# sourceMappingURL=_assert_not_equals.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.12/_assert_not_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert_not_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.12/_assert_not_equals.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,OAAO,GAAE,YAAiB,QAQ3B"}

package/esm/deps/jsr.io/@std/expect/1.0.12/_assert_not_equals.js

@@ -0,0 +1,26 @@
+// 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";
+/**
+ * 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(actual, expected, options = {}) {
+    if (!equal(actual, expected, options)) {
+        return;
+    }
+    const message = buildNotEqualErrorMessage(actual, expected, options !== null && options !== void 0 ? options : {});
+    throw new AssertionError(message);
+}

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

@@ -0,0 +1,4 @@
+export declare function hasAssertions(): void;
+export declare function assertions(num: number): void;
+export declare function emitAssertionTrigger(): void;
+//# sourceMappingURL=_assertions.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.12/_assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assertions.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.12/_assertions.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,SAE5B;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,QAErC;AAED,wBAAgB,oBAAoB,SAGnC"}

package/esm/deps/jsr.io/@std/expect/1.0.12/_assertions.js

@@ -0,0 +1,13 @@
+// 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) {
+    assertionState.setAssertionCount(num);
+}
+export function emitAssertionTrigger() {
+    assertionState.setAssertionTriggered(true);
+    assertionState.updateAssertionTriggerCount();
+}

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

@@ -0,0 +1,46 @@
+export declare abstract class AsymmetricMatcher<T> {
+    protected value: T;
+    protected inverse: boolean;
+    constructor(value: T, inverse?: boolean);
+    abstract equals(other: unknown): boolean;
+}
+export declare class Anything extends AsymmetricMatcher<void> {
+    equals(other: unknown): boolean;
+}
+export declare function anything(): Anything;
+export declare class Any extends AsymmetricMatcher<any> {
+    constructor(value: unknown);
+    equals(other: unknown): boolean;
+}
+export declare function any(c: unknown): Any;
+export declare class ArrayContaining extends AsymmetricMatcher<any[]> {
+    constructor(arr: any[], inverse?: boolean);
+    equals(other: any[]): boolean;
+}
+export declare function arrayContaining(c: any[]): ArrayContaining;
+export declare function arrayNotContaining(c: any[]): ArrayContaining;
+export declare class CloseTo extends AsymmetricMatcher<number> {
+    #private;
+    constructor(num: number, precision?: number);
+    equals(other: number): boolean;
+}
+export declare function closeTo(num: number, numDigits?: number): CloseTo;
+export declare class StringContaining extends AsymmetricMatcher<string> {
+    constructor(str: string, inverse?: boolean);
+    equals(other: string): boolean;
+}
+export declare function stringContaining(str: string): StringContaining;
+export declare function stringNotContaining(str: string): StringContaining;
+export declare class StringMatching extends AsymmetricMatcher<RegExp> {
+    constructor(pattern: string | RegExp, inverse?: boolean);
+    equals(other: string): boolean;
+}
+export declare function stringMatching(pattern: string | RegExp): StringMatching;
+export declare function stringNotMatching(pattern: string | RegExp): StringMatching;
+export declare class ObjectContaining extends AsymmetricMatcher<Record<string, unknown>> {
+    constructor(obj: Record<string, unknown>, inverse?: boolean);
+    equals(other: Record<string, unknown>): boolean;
+}
+export declare function objectContaining(obj: Record<string, unknown>): ObjectContaining;
+export declare function objectNotContaining(obj: Record<string, unknown>): ObjectContaining;
+//# sourceMappingURL=_asymmetric_matchers.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.12/_asymmetric_matchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_asymmetric_matchers.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.12/_asymmetric_matchers.ts"],"names":[],"mappings":"AAMA,8BAAsB,iBAAiB,CAAC,CAAC;IAErC,SAAS,CAAC,KAAK,EAAE,CAAC;IAClB,SAAS,CAAC,OAAO,EAAE,OAAO;gBADhB,KAAK,EAAE,CAAC,EACR,OAAO,GAAE,OAAe;IAEpC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;CACzC;AAED,qBAAa,QAAS,SAAQ,iBAAiB,CAAC,IAAI,CAAC;IACnD,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;CAGhC;AAED,wBAAgB,QAAQ,IAAI,QAAQ,CAEnC;AAED,qBAAa,GAAI,SAAQ,iBAAiB,CAAC,GAAG,CAAC;gBACjC,KAAK,EAAE,OAAO;IAO1B,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;CAkChC;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,GAAG,CAEnC;AAED,qBAAa,eAAgB,SAAQ,iBAAiB,CAAC,GAAG,EAAE,CAAC;gBAC/C,GAAG,EAAE,GAAG,EAAE,EAAE,OAAO,UAAQ;IAIvC,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,OAAO;CAS9B;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,eAAe,CAEzD;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,eAAe,CAE5D;AAED,qBAAa,OAAQ,SAAQ,iBAAiB,CAAC,MAAM,CAAC;;gBAGxC,GAAG,EAAE,MAAM,EAAE,SAAS,GAAE,MAAU;IAK9C,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAgB/B;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED,qBAAa,gBAAiB,SAAQ,iBAAiB,CAAC,MAAM,CAAC;gBACjD,GAAG,EAAE,MAAM,EAAE,OAAO,UAAQ;IAIxC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAI/B;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAE9D;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAEjE;AAED,qBAAa,cAAe,SAAQ,iBAAiB,CAAC,MAAM,CAAC;gBAC/C,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,UAAQ;IAIrD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAI/B;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAEvE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAE1E;AAED,qBAAa,gBACX,SAAQ,iBAAiB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBACtC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,UAAQ;IAIzD,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;CAehD;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,gBAAgB,CAElB;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,gBAAgB,CAElB"}

package/esm/deps/jsr.io/@std/expect/1.0.12/_asymmetric_matchers.js

@@ -0,0 +1,161 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// deno-lint-ignore-file no-explicit-any
+var _CloseTo_precision;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { getCustomEqualityTesters } from "./_custom_equality_tester.js";
+import { equal } from "./_equal.js";
+export class AsymmetricMatcher {
+    constructor(value, inverse = false) {
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: value
+        });
+        Object.defineProperty(this, "inverse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: inverse
+        });
+    }
+}
+export class Anything extends AsymmetricMatcher {
+    equals(other) {
+        return other !== null && other !== undefined;
+    }
+}
+export function anything() {
+    return new Anything();
+}
+export class Any extends AsymmetricMatcher {
+    constructor(value) {
+        if (value === undefined) {
+            throw new TypeError("Expected a constructor function");
+        }
+        super(value);
+    }
+    equals(other) {
+        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) {
+    return new Any(c);
+}
+export class ArrayContaining extends AsymmetricMatcher {
+    constructor(arr, inverse = false) {
+        super(arr, inverse);
+    }
+    equals(other) {
+        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) {
+    return new ArrayContaining(c);
+}
+export function arrayNotContaining(c) {
+    return new ArrayContaining(c, true);
+}
+export class CloseTo extends AsymmetricMatcher {
+    constructor(num, precision = 2) {
+        super(num);
+        _CloseTo_precision.set(this, void 0);
+        __classPrivateFieldSet(this, _CloseTo_precision, precision, "f");
+    }
+    equals(other) {
+        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, -__classPrivateFieldGet(this, _CloseTo_precision, "f")) / 2;
+    }
+}
+_CloseTo_precision = new WeakMap();
+export function closeTo(num, numDigits) {
+    return new CloseTo(num, numDigits);
+}
+export class StringContaining extends AsymmetricMatcher {
+    constructor(str, inverse = false) {
+        super(str, inverse);
+    }
+    equals(other) {
+        const res = typeof other !== "string" ? false : other.includes(this.value);
+        return this.inverse ? !res : res;
+    }
+}
+export function stringContaining(str) {
+    return new StringContaining(str);
+}
+export function stringNotContaining(str) {
+    return new StringContaining(str, true);
+}
+export class StringMatching extends AsymmetricMatcher {
+    constructor(pattern, inverse = false) {
+        super(new RegExp(pattern), inverse);
+    }
+    equals(other) {
+        const res = typeof other !== "string" ? false : this.value.test(other);
+        return this.inverse ? !res : res;
+    }
+}
+export function stringMatching(pattern) {
+    return new StringMatching(pattern);
+}
+export function stringNotMatching(pattern) {
+    return new StringMatching(pattern, true);
+}
+export class ObjectContaining extends AsymmetricMatcher {
+    constructor(obj, inverse = false) {
+        super(obj, inverse);
+    }
+    equals(other) {
+        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) {
+    return new ObjectContaining(obj);
+}
+export function objectNotContaining(obj) {
+    return new ObjectContaining(obj, true);
+}

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

@@ -0,0 +1,6 @@
+import type { EqualOptions } from "./_types.js";
+type EqualErrorMessageOptions = Pick<EqualOptions, "formatter" | "msg">;
+export declare function buildEqualErrorMessage<T>(actual: T, expected: T, options: EqualErrorMessageOptions): string;
+export declare function buildNotEqualErrorMessage<T>(actual: T, expected: T, options: EqualErrorMessageOptions): string;
+export {};
+//# sourceMappingURL=_build_message.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.12/_build_message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_build_message.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.12/_build_message.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,KAAK,wBAAwB,GAAG,IAAI,CAClC,YAAY,EACZ,WAAW,GAAG,KAAK,CACpB,CAAC;AAMF,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,OAAO,EAAE,wBAAwB,GAChC,MAAM,CAgBR;AAED,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,OAAO,EAAE,wBAAwB,GAChC,MAAM,CAOR"}

package/esm/deps/jsr.io/@std/expect/1.0.12/_build_message.js

@@ -0,0 +1,29 @@
+// 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";
+function isString(value) {
+    return typeof value === "string";
+}
+export function buildEqualErrorMessage(actual, expected, options) {
+    const { formatter = format, msg } = options !== null && options !== void 0 ? 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(actual, expected, options) {
+    const { msg } = options !== null && options !== void 0 ? options : {};
+    const actualString = String(actual);
+    const expectedString = String(expected);
+    const msgPrefix = msg ? `${msg}: ` : "";
+    return `${msgPrefix}Expected actual: ${actualString} not to be: ${expectedString}.`;
+}

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

@@ -0,0 +1,4 @@
+import type { Tester } from "./_types.js";
+export declare function addCustomEqualityTesters(newTesters: Tester[]): void;
+export declare function getCustomEqualityTesters(): Tester[];
+//# sourceMappingURL=_custom_equality_tester.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.12/_custom_equality_tester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_custom_equality_tester.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.12/_custom_equality_tester.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAI1C,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,QAQ5D;AAED,wBAAgB,wBAAwB,aAEvC"}

package/esm/deps/jsr.io/@std/expect/1.0.12/_custom_equality_tester.js

@@ -0,0 +1,11 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+const customEqualityTesters = [];
+export function addCustomEqualityTesters(newTesters) {
+    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;
+}

package/esm/deps/jsr.io/@std/expect/1.0.12/_equal.d.ts

@@ -0,0 +1,9 @@
+import type { EqualOptions } from "./_types.js";
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ * @param options for the equality check
+ */
+export declare function equal(c: unknown, d: unknown, options?: EqualOptions): boolean;
+//# sourceMappingURL=_equal.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.12/_equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.12/_equal.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA+BhD;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CA4L7E"}