@goast/typescript 0.4.1-beta1 → 0.4.1

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

@@ -0,0 +1,139 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equal = equal;
+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;
+}
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param c The actual value
+ * @param d The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+ * ```
+ */
+function equal(c, d) {
+    const seen = new Map();
+    return (function compare(a, b) {
+        // 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);
+        }
+        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 (typeof a === "number" && typeof b === "number") {
+            return Number.isNaN(a) && Number.isNaN(b) || a === b;
+        }
+        if (Object.is(a, b)) {
+            return true;
+        }
+        if (a && typeof a === "object" && b && typeof b === "object") {
+            if (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 (a instanceof WeakRef || b instanceof WeakRef) {
+                if (!(a instanceof WeakRef && b instanceof WeakRef))
+                    return false;
+                return compare(a.deref(), b.deref());
+            }
+            if (seen.get(a) === b) {
+                return true;
+            }
+            if (Object.keys(a).length !== Object.keys(b).length) {
+                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) && (!(key in b))) || ((key in b) && (!(key in a)))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    })(c, d);
+}

package/script/deps/jsr.io/@std/assert/1.0.6/equals.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 Usage
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
+ * ```
+ *
+ * @typeParam T The type of the values to compare. This is usually inferred.
+ * @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 assertEquals<T>(actual: T, expected: T, msg?: string): void;
+//# sourceMappingURL=equals.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.6/equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.6/equals.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAkBb"}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertEquals = assertEquals;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const equal_js_1 = require("./equal.js");
+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 assertion_error_js_1 = require("./assertion_error.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 Usage
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
+ * ```
+ *
+ * @typeParam T The type of the values to compare. This is usually inferred.
+ * @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 assertEquals(actual, expected, msg) {
+    if ((0, equal_js_1.equal)(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message = `Values are not equal${msgSuffix}`;
+    const actualString = (0, format_js_1.format)(actual);
+    const expectedString = (0, format_js_1.format)(expected);
+    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 = `${message}\n${diffMsg}`;
+    throw new assertion_error_js_1.AssertionError(message);
+}

package/script/deps/jsr.io/@std/assert/1.0.6/false.d.ts

@@ -0,0 +1,18 @@
+/** Assertion condition for {@linkcode assertFalse}. */
+export type Falsy = false | 0 | 0n | "" | null | undefined;
+/**
+ * Make an assertion, error will be thrown if `expr` have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertFalse } from "@std/assert";
+ *
+ * assertFalse(false); // Doesn't throw
+ * assertFalse(true); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;
+//# sourceMappingURL=false.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.6/false.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"false.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.6/false.ts"],"names":[],"mappings":"AAIA,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAI1E"}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertFalse = assertFalse;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion, error will be thrown if `expr` have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertFalse } from "@std/assert";
+ *
+ * assertFalse(false); // Doesn't throw
+ * assertFalse(true); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertFalse(expr, msg = "") {
+    if (expr) {
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}

package/script/deps/jsr.io/@std/assert/1.0.6/instance_of.d.ts

@@ -0,0 +1,23 @@
+/** Any constructor */
+export type AnyConstructor = new (...args: any[]) => any;
+/** Gets constructor type */
+export type GetConstructorType<T extends AnyConstructor> = InstanceType<T>;
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertInstanceOf } from "@std/assert";
+ *
+ * assertInstanceOf(new Date(), Date); // Doesn't throw
+ * assertInstanceOf(new Date(), Number); // Throws
+ * ```
+ *
+ * @typeParam T The expected type of the object.
+ * @param actual The object to check.
+ * @param expectedType The expected class constructor.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertInstanceOf<T extends abstract new (...args: any[]) => any>(actual: unknown, expectedType: T, msg?: string): asserts actual is InstanceType<T>;
+//# sourceMappingURL=instance_of.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.6/instance_of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance_of.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.6/instance_of.ts"],"names":[],"mappings":"AAIA,sBAAsB;AAEtB,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AACzD,4BAA4B;AAC5B,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,cAAc,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;AAE3E;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAE9B,CAAC,SAAS,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAE9C,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,CAAC,EACf,GAAG,SAAK,GACP,OAAO,CAAC,MAAM,IAAI,YAAY,CAAC,CAAC,CAAC,CA6BnC"}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertInstanceOf = assertInstanceOf;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertInstanceOf } from "@std/assert";
+ *
+ * assertInstanceOf(new Date(), Date); // Doesn't throw
+ * assertInstanceOf(new Date(), Number); // Throws
+ * ```
+ *
+ * @typeParam T The expected type of the object.
+ * @param actual The object to check.
+ * @param expectedType The expected class constructor.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertInstanceOf(actual, expectedType, msg = "") {
+    var _a, _b;
+    if (actual instanceof expectedType)
+        return;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const expectedTypeStr = expectedType.name;
+    let actualTypeStr = "";
+    if (actual === null) {
+        actualTypeStr = "null";
+    }
+    else if (actual === undefined) {
+        actualTypeStr = "undefined";
+    }
+    else if (typeof actual === "object") {
+        actualTypeStr = (_b = (_a = actual.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "Object";
+    }
+    else {
+        actualTypeStr = typeof actual;
+    }
+    if (expectedTypeStr === actualTypeStr) {
+        msg =
+            `Expected object to be an instance of "${expectedTypeStr}"${msgSuffix}`;
+    }
+    else if (actualTypeStr === "function") {
+        msg =
+            `Expected object to be an instance of "${expectedTypeStr}" but was not an instanced object${msgSuffix}`;
+    }
+    else {
+        msg =
+            `Expected object to be an instance of "${expectedTypeStr}" but was "${actualTypeStr}"${msgSuffix}`;
+    }
+    throw new assertion_error_js_1.AssertionError(msg);
+}

package/script/deps/jsr.io/@std/assert/1.0.6/is_error.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertIsError } from "@std/assert";
+ *
+ * assertIsError(null); // Throws
+ * assertIsError(new RangeError("Out of range")); // Doesn't throw
+ * assertIsError(new RangeError("Out of range"), SyntaxError); // Throws
+ * assertIsError(new RangeError("Out of range"), SyntaxError, "Out of range"); // Doesn't throw
+ * assertIsError(new RangeError("Out of range"), SyntaxError, "Within range"); // Throws
+ * ```
+ *
+ * @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=is_error.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.6/is_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.6/is_error.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;GAsBG;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/script/deps/jsr.io/@std/assert/1.0.6/is_error.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsError = assertIsError;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+const styles_js_1 = require("../../internal/1.0.4/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.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertIsError } from "@std/assert";
+ *
+ * assertIsError(null); // Throws
+ * assertIsError(new RangeError("Out of range")); // Doesn't throw
+ * assertIsError(new RangeError("Out of range"), SyntaxError); // Throws
+ * assertIsError(new RangeError("Out of range"), SyntaxError, "Out of range"); // Doesn't throw
+ * assertIsError(new RangeError("Out of range"), SyntaxError, "Within range"); // Throws
+ * ```
+ *
+ * @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.
+ */
+function assertIsError(error, 
+// deno-lint-ignore no-explicit-any
+ErrorClass, msgMatches, msg) {
+    var _a;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    if (!(error instanceof Error)) {
+        throw new assertion_error_js_1.AssertionError(`Expected "error" to be an Error object${msgSuffix}}`);
+    }
+    if (ErrorClass && !(error instanceof ErrorClass)) {
+        msg =
+            `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}"${msgSuffix}`;
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+    let msgCheck;
+    if (typeof msgMatches === "string") {
+        msgCheck = (0, styles_js_1.stripAnsiCode)(error.message).includes((0, styles_js_1.stripAnsiCode)(msgMatches));
+    }
+    if (msgMatches instanceof RegExp) {
+        msgCheck = msgMatches.test((0, styles_js_1.stripAnsiCode)(error.message));
+    }
+    if (msgMatches && !msgCheck) {
+        msg = `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)}${msgSuffix}`;
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}

package/script/deps/jsr.io/@std/assert/1.0.6/match.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertMatch } from "@std/assert";
+ *
+ * assertMatch("Raptor", /Raptor/); // Doesn't throw
+ * assertMatch("Denosaurus", /Raptor/); // Throws
+ * ```
+ *
+ * @param actual The actual value to be matched.
+ * @param expected The expected pattern to match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
+//# sourceMappingURL=match.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.6/match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.6/match.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,QAMb"}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertMatch = assertMatch;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertMatch } from "@std/assert";
+ *
+ * assertMatch("Raptor", /Raptor/); // Doesn't throw
+ * assertMatch("Denosaurus", /Raptor/); // Throws
+ * ```
+ *
+ * @param actual The actual value to be matched.
+ * @param expected The expected pattern to match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertMatch(actual, expected, msg) {
+    if (expected.test(actual))
+        return;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${actual}" to match: "${expected}"${msgSuffix}`;
+    throw new assertion_error_js_1.AssertionError(msg);
+}

package/script/deps/jsr.io/@std/assert/1.0.6/not_instance_of.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotInstanceOf } from "@std/assert";
+ *
+ * assertNotInstanceOf(new Date(), Number); // Doesn't throw
+ * assertNotInstanceOf(new Date(), Date); // Throws
+ * ```
+ *
+ * @typeParam A The type of the object to check.
+ * @typeParam T The type of the class to check against.
+ * @param actual The object to check.
+ * @param unexpectedType The class constructor to check against.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: abstract new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;
+//# sourceMappingURL=not_instance_of.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.6/not_instance_of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not_instance_of.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.6/not_instance_of.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EACtC,MAAM,EAAE,CAAC,EAET,cAAc,EAAE,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAClD,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAKjC"}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNotInstanceOf = assertNotInstanceOf;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const false_js_1 = require("./false.js");
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotInstanceOf } from "@std/assert";
+ *
+ * assertNotInstanceOf(new Date(), Number); // Doesn't throw
+ * assertNotInstanceOf(new Date(), Date); // Throws
+ * ```
+ *
+ * @typeParam A The type of the object to check.
+ * @typeParam T The type of the class to check against.
+ * @param actual The object to check.
+ * @param unexpectedType The class constructor to check against.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertNotInstanceOf(actual, 
+// deno-lint-ignore no-explicit-any
+unexpectedType, msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg =
+        `Expected object to not be an instance of "${typeof unexpectedType}"${msgSuffix}`;
+    (0, false_js_1.assertFalse)(actual instanceof unexpectedType, msg);
+}

package/script/deps/jsr.io/@std/assert/1.0.6/not_match.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotMatch } from "@std/assert";
+ *
+ * assertNotMatch("Denosaurus", /Raptor/); // Doesn't throw
+ * assertNotMatch("Raptor", /Raptor/); // Throws
+ * ```
+ *
+ * @param actual The actual value to match.
+ * @param expected The expected value to not match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+//# sourceMappingURL=not_match.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.6/not_match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not_match.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.6/not_match.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,QAMb"}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNotMatch = assertNotMatch;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotMatch } from "@std/assert";
+ *
+ * assertNotMatch("Denosaurus", /Raptor/); // Doesn't throw
+ * assertNotMatch("Raptor", /Raptor/); // Throws
+ * ```
+ *
+ * @param actual The actual value to match.
+ * @param expected The expected value to not match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertNotMatch(actual, expected, msg) {
+    if (!expected.test(actual))
+        return;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${actual}" to not match: "${expected}"${msgSuffix}`;
+    throw new assertion_error_js_1.AssertionError(msg);
+}

package/script/deps/jsr.io/@std/assert/1.0.6/not_strict_equals.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Make an assertion that `actual` and `expected` are not strictly equal, using
+ * {@linkcode Object.is} for equality comparison. If the values are strictly
+ * equal then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertNotStrictEquals } from "@std/assert";
+ *
+ * assertNotStrictEquals(1, 1); // Throws
+ * assertNotStrictEquals(1, 2); // Doesn't throw
+ *
+ * assertNotStrictEquals(0, 0); // Throws
+ * assertNotStrictEquals(0, -0); // Doesn't throw
+ * ```
+ *
+ * @typeParam T The type of the values to compare.
+ * @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 assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+//# sourceMappingURL=not_strict_equals.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.6/not_strict_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not_strict_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.6/not_strict_equals.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAYb"}