@goast/core 0.4.0-beta3 → 0.4.0

package/script/deps/jsr.io/@std/assert/1.0.6/strict_equals.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertStrictEquals = assertStrictEquals;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const build_message_js_1 = require("../../internal/1.0.4/build_message.js");
+const diff_js_1 = require("../../internal/1.0.4/diff.js");
+const diff_str_js_1 = require("../../internal/1.0.4/diff_str.js");
+const format_js_1 = require("../../internal/1.0.4/format.js");
+const styles_js_1 = require("../../internal/1.0.4/styles.js");
+const assertion_error_js_1 = require("./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.
+ */
+function assertStrictEquals(actual, expected, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message;
+    const actualString = (0, format_js_1.format)(actual);
+    const expectedString = (0, format_js_1.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${(0, styles_js_1.red)(withOffset)}\n`;
+    }
+    else {
+        const stringDiff = (typeof actual === "string") &&
+            (typeof expected === "string");
+        const diffResult = stringDiff
+            ? (0, diff_str_js_1.diffStr)(actual, expected)
+            : (0, diff_js_1.diff)(actualString.split("\n"), expectedString.split("\n"));
+        const diffMsg = (0, build_message_js_1.buildMessage)(diffResult, { stringDiff }).join("\n");
+        message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
+    }
+    throw new assertion_error_js_1.AssertionError(message);
+}

package/script/deps/jsr.io/@std/expect/1.0.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_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.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_assert_equals.js

@@ -0,0 +1,32 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertEquals = assertEquals;
+// This file is copied from `std/assert`.
+const assertion_error_js_1 = require("../../assert/1.0.6/assertion_error.js");
+const _build_message_js_1 = require("./_build_message.js");
+const _equal_js_1 = require("./_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.
+ */
+function assertEquals(actual, expected, options) {
+    if ((0, _equal_js_1.equal)(actual, expected, options)) {
+        return;
+    }
+    const message = (0, _build_message_js_1.buildEqualErrorMessage)(actual, expected, options !== null && options !== void 0 ? options : {});
+    throw new assertion_error_js_1.AssertionError(message);
+}

package/script/deps/jsr.io/@std/expect/1.0.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_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.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_assert_not_equals.js

@@ -0,0 +1,29 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNotEquals = assertNotEquals;
+// This file is copied from `std/assert`.
+const assertion_error_js_1 = require("../../assert/1.0.6/assertion_error.js");
+const _build_message_js_1 = require("./_build_message.js");
+const _equal_js_1 = require("./_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
+ * ```
+ */
+function assertNotEquals(actual, expected, options = {}) {
+    if (!(0, _equal_js_1.equal)(actual, expected, options)) {
+        return;
+    }
+    const message = (0, _build_message_js_1.buildNotEqualErrorMessage)(actual, expected, options);
+    throw new assertion_error_js_1.AssertionError(message);
+}

package/script/deps/jsr.io/@std/expect/1.0.5/_assertion.d.ts

@@ -0,0 +1,3 @@
+export declare function hasAssertions(): void;
+export declare function emitAssertionTrigger(): void;
+//# sourceMappingURL=_assertion.d.ts.map

package/script/deps/jsr.io/@std/expect/1.0.5/_assertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assertion.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.5/_assertion.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,SAE5B;AAED,wBAAgB,oBAAoB,SAEnC"}

package/script/deps/jsr.io/@std/expect/1.0.5/_assertion.js

@@ -0,0 +1,13 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAssertions = hasAssertions;
+exports.emitAssertionTrigger = emitAssertionTrigger;
+const assertion_state_js_1 = require("../../internal/1.0.4/assertion_state.js");
+const assertionState = (0, assertion_state_js_1.getAssertionState)();
+function hasAssertions() {
+    assertionState.setAssertionCheck(true);
+}
+function emitAssertionTrigger() {
+    assertionState.setAssertionTriggered(true);
+}

package/script/deps/jsr.io/@std/expect/1.0.5/_asymmetric_matchers.d.ts

@@ -0,0 +1,36 @@
+export declare abstract class AsymmetricMatcher<T> {
+    protected value: T;
+    constructor(value: T);
+    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[]);
+    equals(other: any[]): boolean;
+}
+export declare function arrayContaining(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);
+    equals(other: string): boolean;
+}
+export declare function stringContaining(str: string): StringContaining;
+export declare class StringMatching extends AsymmetricMatcher<RegExp> {
+    constructor(pattern: string | RegExp);
+    equals(other: string): boolean;
+}
+export declare function stringMatching(pattern: string | RegExp): StringMatching;
+//# sourceMappingURL=_asymmetric_matchers.d.ts.map

package/script/deps/jsr.io/@std/expect/1.0.5/_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.5/_asymmetric_matchers.ts"],"names":[],"mappings":"AAGA,8BAAsB,iBAAiB,CAAC,CAAC;IAErC,SAAS,CAAC,KAAK,EAAE,CAAC;gBAAR,KAAK,EAAE,CAAC;IAEpB,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;IAItB,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,OAAO;CAG9B;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,eAAe,CAEzD;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;IAIvB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAO/B;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAE9D;AAED,qBAAa,cAAe,SAAQ,iBAAiB,CAAC,MAAM,CAAC;gBAC/C,OAAO,EAAE,MAAM,GAAG,MAAM;IAIpC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAO/B;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAEvE"}

package/script/deps/jsr.io/@std/expect/1.0.5/_asymmetric_matchers.js

@@ -0,0 +1,140 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// deno-lint-ignore-file no-explicit-any
+var _CloseTo_precision;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringMatching = exports.StringContaining = exports.CloseTo = exports.ArrayContaining = exports.Any = exports.Anything = exports.AsymmetricMatcher = void 0;
+exports.anything = anything;
+exports.any = any;
+exports.arrayContaining = arrayContaining;
+exports.closeTo = closeTo;
+exports.stringContaining = stringContaining;
+exports.stringMatching = stringMatching;
+const tslib_1 = require("tslib");
+class AsymmetricMatcher {
+    constructor(value) {
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: value
+        });
+    }
+}
+exports.AsymmetricMatcher = AsymmetricMatcher;
+class Anything extends AsymmetricMatcher {
+    equals(other) {
+        return other !== null && other !== undefined;
+    }
+}
+exports.Anything = Anything;
+function anything() {
+    return new Anything();
+}
+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;
+    }
+}
+exports.Any = Any;
+function any(c) {
+    return new Any(c);
+}
+class ArrayContaining extends AsymmetricMatcher {
+    constructor(arr) {
+        super(arr);
+    }
+    equals(other) {
+        return Array.isArray(other) && this.value.every((e) => other.includes(e));
+    }
+}
+exports.ArrayContaining = ArrayContaining;
+function arrayContaining(c) {
+    return new ArrayContaining(c);
+}
+class CloseTo extends AsymmetricMatcher {
+    constructor(num, precision = 2) {
+        super(num);
+        _CloseTo_precision.set(this, void 0);
+        tslib_1.__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, -tslib_1.__classPrivateFieldGet(this, _CloseTo_precision, "f")) / 2;
+    }
+}
+exports.CloseTo = CloseTo;
+_CloseTo_precision = new WeakMap();
+function closeTo(num, numDigits) {
+    return new CloseTo(num, numDigits);
+}
+class StringContaining extends AsymmetricMatcher {
+    constructor(str) {
+        super(str);
+    }
+    equals(other) {
+        if (typeof other !== "string") {
+            return false;
+        }
+        return other.includes(this.value);
+    }
+}
+exports.StringContaining = StringContaining;
+function stringContaining(str) {
+    return new StringContaining(str);
+}
+class StringMatching extends AsymmetricMatcher {
+    constructor(pattern) {
+        super(new RegExp(pattern));
+    }
+    equals(other) {
+        if (typeof other !== "string") {
+            return false;
+        }
+        return this.value.test(other);
+    }
+}
+exports.StringMatching = StringMatching;
+function stringMatching(pattern) {
+    return new StringMatching(pattern);
+}

package/script/deps/jsr.io/@std/expect/1.0.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_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.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_build_message.js

@@ -0,0 +1,33 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEqualErrorMessage = buildEqualErrorMessage;
+exports.buildNotEqualErrorMessage = buildNotEqualErrorMessage;
+const build_message_js_1 = require("../../internal/1.0.4/build_message.js");
+const diff_js_1 = require("../../internal/1.0.4/diff.js");
+const diff_str_js_1 = require("../../internal/1.0.4/diff_str.js");
+const format_js_1 = require("../../internal/1.0.4/format.js");
+function isString(value) {
+    return typeof value === "string";
+}
+function buildEqualErrorMessage(actual, expected, options) {
+    const { formatter = format_js_1.format, msg } = options !== null && options !== void 0 ? options : {};
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const actualString = formatter(actual);
+    const expectedString = formatter(expected);
+    let message = `Values are not equal${msgSuffix}`;
+    const stringDiff = isString(actual) && isString(expected);
+    const diffResult = stringDiff
+        ? (0, diff_str_js_1.diffStr)(actual, expected)
+        : (0, diff_js_1.diff)(actualString.split("\n"), expectedString.split("\n"));
+    const diffMsg = (0, build_message_js_1.buildMessage)(diffResult, { stringDiff }).join("\n");
+    message = `${message}\n${diffMsg}`;
+    return message;
+}
+function buildNotEqualErrorMessage(actual, expected, options) {
+    const { msg } = options !== null && options !== void 0 ? options : {};
+    const actualString = String(actual);
+    const expectedString = String(expected);
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    return `Expected actual: ${actualString} not to be: ${expectedString}${msgSuffix}`;
+}

package/script/deps/jsr.io/@std/expect/1.0.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_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.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_custom_equality_tester.js

@@ -0,0 +1,15 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCustomEqualityTesters = addCustomEqualityTesters;
+exports.getCustomEqualityTesters = getCustomEqualityTesters;
+const customEqualityTesters = [];
+function addCustomEqualityTesters(newTesters) {
+    if (!Array.isArray(newTesters)) {
+        throw new TypeError(`customEqualityTester expects an array of Testers. But got ${typeof newTesters}`);
+    }
+    customEqualityTesters.push(...newTesters);
+}
+function getCustomEqualityTesters() {
+    return customEqualityTesters;
+}

package/script/deps/jsr.io/@std/expect/1.0.5/_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/script/deps/jsr.io/@std/expect/1.0.5/_equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.5/_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,CA2L7E"}

package/script/deps/jsr.io/@std/expect/1.0.5/_equal.js

@@ -0,0 +1,194 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equal = equal;
+const _asymmetric_matchers_js_1 = require("./_asymmetric_matchers.js");
+function isKeyedCollection(x) {
+    return x instanceof Set || x instanceof Map;
+}
+function constructorsEqual(a, b) {
+    return a.constructor === b.constructor ||
+        a.constructor === Object && !b.constructor ||
+        !a.constructor && b.constructor === Object;
+}
+function asymmetricEqual(a, b) {
+    const asymmetricA = a instanceof _asymmetric_matchers_js_1.AsymmetricMatcher;
+    const asymmetricB = b instanceof _asymmetric_matchers_js_1.AsymmetricMatcher;
+    if (asymmetricA && asymmetricB) {
+        return undefined;
+    }
+    if (asymmetricA) {
+        return a.equals(b);
+    }
+    if (asymmetricB) {
+        return b.equals(a);
+    }
+}
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ * @param options for the equality check
+ */
+function equal(c, d, options) {
+    const { customTesters = [], strictCheck } = options !== null && options !== void 0 ? options : {};
+    const seen = new Map();
+    return (function compare(a, b) {
+        if (customTesters === null || customTesters === void 0 ? void 0 : customTesters.length) {
+            for (const customTester of customTesters) {
+                const testContext = {
+                    equal,
+                };
+                const pass = customTester.call(testContext, a, b, customTesters);
+                if (pass !== undefined) {
+                    return pass;
+                }
+            }
+        }
+        // Have to render RegExp & Date for string comparison
+        // unless it's mistreated as object
+        if (a &&
+            b &&
+            ((a instanceof RegExp && b instanceof RegExp) ||
+                (a instanceof URL && b instanceof URL))) {
+            return String(a) === String(b);
+        }
+        const asymmetric = asymmetricEqual(a, b);
+        if (asymmetric !== undefined) {
+            return asymmetric;
+        }
+        if (a instanceof Date && b instanceof Date) {
+            const aTime = a.getTime();
+            const bTime = b.getTime();
+            // Check for NaN equality manually since NaN is not
+            // equal to itself.
+            if (Number.isNaN(aTime) && Number.isNaN(bTime)) {
+                return true;
+            }
+            return aTime === bTime;
+        }
+        if (a instanceof Error && b instanceof Error) {
+            return a.message === b.message;
+        }
+        if (typeof a === "number" && typeof b === "number") {
+            return Number.isNaN(a) && Number.isNaN(b) || a === b;
+        }
+        if (a === null || b === null) {
+            return a === b;
+        }
+        const className = Object.prototype.toString.call(a);
+        if (className !== Object.prototype.toString.call(b)) {
+            return false;
+        }
+        if (Object.is(a, b)) {
+            return true;
+        }
+        if (a && typeof a === "object" && b && typeof b === "object") {
+            if (strictCheck && a && b && !constructorsEqual(a, b)) {
+                return false;
+            }
+            if (a instanceof WeakMap || b instanceof WeakMap) {
+                if (!(a instanceof WeakMap && b instanceof WeakMap))
+                    return false;
+                throw new TypeError("Cannot compare WeakMap instances");
+            }
+            if (a instanceof WeakSet || b instanceof WeakSet) {
+                if (!(a instanceof WeakSet && b instanceof WeakSet))
+                    return false;
+                throw new TypeError("Cannot compare WeakSet instances");
+            }
+            if (seen.get(a) === b) {
+                return true;
+            }
+            const aKeys = Object.keys(a !== null && a !== void 0 ? a : {});
+            const bKeys = Object.keys(b !== null && b !== void 0 ? b : {});
+            let aLen = aKeys.length;
+            let bLen = bKeys.length;
+            if (!strictCheck) {
+                if (aLen > 0) {
+                    for (let i = 0; i < aKeys.length; i += 1) {
+                        const key = aKeys[i];
+                        if ((key in a) && (a[key] === undefined) &&
+                            !(key in b)) {
+                            aLen -= 1;
+                        }
+                    }
+                }
+                if (bLen > 0) {
+                    for (let i = 0; i < bKeys.length; i += 1) {
+                        const key = bKeys[i];
+                        if ((key in b) && (b[key] === undefined) &&
+                            !(key in a)) {
+                            bLen -= 1;
+                        }
+                    }
+                }
+            }
+            if (aLen !== bLen) {
+                return false;
+            }
+            seen.set(a, b);
+            if (isKeyedCollection(a) && isKeyedCollection(b)) {
+                if (a.size !== b.size) {
+                    return false;
+                }
+                const aKeys = [...a.keys()];
+                const primitiveKeysFastPath = aKeys.every((k) => {
+                    return typeof k === "string" ||
+                        typeof k === "number" ||
+                        typeof k === "boolean" ||
+                        typeof k === "bigint" ||
+                        typeof k === "symbol" ||
+                        k == null;
+                });
+                if (primitiveKeysFastPath) {
+                    if (a instanceof Set) {
+                        return a.symmetricDifference(b).size === 0;
+                    }
+                    for (const key of aKeys) {
+                        if (!b.has(key) ||
+                            !compare(a.get(key), b.get(key))) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+                let unmatchedEntries = a.size;
+                for (const [aKey, aValue] of a.entries()) {
+                    for (const [bKey, bValue] of b.entries()) {
+                        /* Given that Map keys can be references, we need
+                         * to ensure that they are also deeply equal */
+                        if (!compare(aKey, bKey))
+                            continue;
+                        if ((aKey === aValue && bKey === bValue) ||
+                            (compare(aValue, bValue))) {
+                            unmatchedEntries--;
+                            break;
+                        }
+                    }
+                }
+                return unmatchedEntries === 0;
+            }
+            const merged = { ...a, ...b };
+            for (const key of [
+                ...Object.getOwnPropertyNames(merged),
+                ...Object.getOwnPropertySymbols(merged),
+            ]) {
+                if (!compare(a && a[key], b && b[key])) {
+                    return false;
+                }
+                if (((key in a) && (a[key] !== undefined) && (!(key in b))) ||
+                    ((key in b) && (b[key] !== undefined) && (!(key in a)))) {
+                    return false;
+                }
+            }
+            if (a instanceof WeakRef || b instanceof WeakRef) {
+                if (!(a instanceof WeakRef && b instanceof WeakRef))
+                    return false;
+                return compare(a.deref(), b.deref());
+            }
+            return true;
+        }
+        return false;
+    })(c, d);
+}

package/script/deps/jsr.io/@std/expect/1.0.5/_extend.d.ts

@@ -0,0 +1,4 @@
+import type { Matchers } from "./_types.js";
+export declare function getExtendMatchers(): {};
+export declare function setExtendMatchers(newExtendMatchers: Matchers): void;
+//# sourceMappingURL=_extend.d.ts.map

package/script/deps/jsr.io/@std/expect/1.0.5/_extend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_extend.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.5/_extend.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAI5C,wBAAgB,iBAAiB,OAEhC;AAED,wBAAgB,iBAAiB,CAAC,iBAAiB,EAAE,QAAQ,QAK5D"}