@goast/kotlin 0.4.12 → 0.4.14-beta1

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

@@ -1,183 +0,0 @@
-var _a;
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import * as dntShim from "../../../../../_dnt.test_shims.js";
-function isKeyedCollection(x) {
-    return x instanceof Set || x instanceof Map;
-}
-function prototypesEqual(a, b) {
-    const pa = Object.getPrototypeOf(a);
-    const pb = Object.getPrototypeOf(b);
-    return pa === pb ||
-        pa === Object.prototype && pb === null ||
-        pa === null && pb === Object.prototype;
-}
-function isBasicObjectOrArray(obj) {
-    const proto = Object.getPrototypeOf(obj);
-    return proto === null || proto === Object.prototype ||
-        proto === Array.prototype;
-}
-// Slightly faster than Reflect.ownKeys in V8 as of 12.9.202.13-rusty (2024-10-28)
-function ownKeys(obj) {
-    return [
-        ...Object.getOwnPropertyNames(obj),
-        ...Object.getOwnPropertySymbols(obj),
-    ];
-}
-function getKeysDeep(obj) {
-    const keys = new Set();
-    while (obj !== Object.prototype && obj !== Array.prototype && obj != null) {
-        for (const key of ownKeys(obj)) {
-            keys.add(key);
-        }
-        obj = Object.getPrototypeOf(obj);
-    }
-    return keys;
-}
-// deno-lint-ignore no-explicit-any
-const Temporal = (_a = dntShim.dntGlobalThis.Temporal) !== null && _a !== void 0 ? _a : new Proxy({}, { get: () => { } });
-/** A non-exhaustive list of prototypes that can be accurately fast-path compared with `String(instance)` */
-const stringComparablePrototypes = new Set([
-    Intl.Locale,
-    RegExp,
-    Temporal.Duration,
-    Temporal.Instant,
-    Temporal.PlainDate,
-    Temporal.PlainDateTime,
-    Temporal.PlainTime,
-    Temporal.PlainYearMonth,
-    Temporal.PlainMonthDay,
-    Temporal.ZonedDateTime,
-    URL,
-    URLSearchParams,
-].filter((x) => x != null).map((x) => x.prototype));
-function isPrimitive(x) {
-    return typeof x === "string" ||
-        typeof x === "number" ||
-        typeof x === "boolean" ||
-        typeof x === "bigint" ||
-        typeof x === "symbol" ||
-        x == null;
-}
-const TypedArray = Object.getPrototypeOf(Uint8Array);
-function compareTypedArrays(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < b.length; i++) {
-        if (!sameValueZero(a[i], b[i]))
-            return false;
-    }
-    return true;
-}
-/** Check both strict equality (`0 == -0`) and `Object.is` (`NaN == NaN`) */
-function sameValueZero(a, b) {
-    return a === b || Object.is(a, b);
-}
-/**
- * Deep equality comparison used in assertions.
- *
- * @param a The actual value
- * @param b 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`
- * ```
- */
-export function equal(a, b) {
-    const seen = new Map();
-    return (function compare(a, b) {
-        if (sameValueZero(a, b))
-            return true;
-        if (isPrimitive(a) || isPrimitive(b))
-            return false;
-        if (a instanceof Date && b instanceof Date) {
-            return Object.is(a.getTime(), b.getTime());
-        }
-        if (a && typeof a === "object" && b && typeof b === "object") {
-            if (!prototypesEqual(a, b)) {
-                return false;
-            }
-            if (a instanceof TypedArray) {
-                return compareTypedArrays(a, b);
-            }
-            if (a instanceof WeakMap) {
-                throw new TypeError("cannot compare WeakMap instances");
-            }
-            if (a instanceof WeakSet) {
-                throw new TypeError("cannot compare WeakSet instances");
-            }
-            if (a instanceof WeakRef) {
-                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(isPrimitive);
-                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;
-            }
-            let keys;
-            if (isBasicObjectOrArray(a)) {
-                // fast path
-                keys = ownKeys({ ...a, ...b });
-            }
-            else if (stringComparablePrototypes.has(Object.getPrototypeOf(a))) {
-                // medium path
-                return String(a) === String(b);
-            }
-            else {
-                // slow path
-                keys = getKeysDeep(a).union(getKeysDeep(b));
-            }
-            for (const key of keys) {
-                if (!compare(a[key], b[key])) {
-                    return false;
-                }
-                if (((key in a) && (!(key in b))) || ((key in b) && (!(key in a)))) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
-    })(a, b);
-}

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

@@ -1,35 +0,0 @@
-/**
- * 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.
- *
- * Note: When comparing `Blob` objects, you should first convert them to
- * `Uint8Array` using the `Blob.bytes()` method and then compare their
- * contents.
- *
- * @example Usage
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals("world", "world"); // Doesn't throw
- * assertEquals("hello", "world"); // Throws
- * ```
- * @example Compare `Blob` objects
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * const bytes1 = await new Blob(["foo"]).bytes();
- * const bytes2 = await new Blob(["foo"]).bytes();
- *
- * assertEquals(bytes1, bytes2);
- * ```
- *
- * @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/esm/deps/jsr.io/@std/assert/1.0.11/equals.d.ts.map

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

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

@@ -1,58 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { equal } from "./equal.js";
-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 { AssertionError } from "./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.
- *
- * Note: When comparing `Blob` objects, you should first convert them to
- * `Uint8Array` using the `Blob.bytes()` method and then compare their
- * contents.
- *
- * @example Usage
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals("world", "world"); // Doesn't throw
- * assertEquals("hello", "world"); // Throws
- * ```
- * @example Compare `Blob` objects
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * const bytes1 = await new Blob(["foo"]).bytes();
- * const bytes2 = await new Blob(["foo"]).bytes();
- *
- * assertEquals(bytes1, bytes2);
- * ```
- *
- * @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 function assertEquals(actual, expected, msg) {
-    if (equal(actual, expected)) {
-        return;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    let message = `Values are not equal${msgSuffix}`;
-    const actualString = format(actual);
-    const expectedString = format(expected);
-    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 = `${message}\n${diffMsg}`;
-    throw new AssertionError(message);
-}

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

@@ -1,18 +0,0 @@
-/** 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/esm/deps/jsr.io/@std/assert/1.0.11/false.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"false.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/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/esm/deps/jsr.io/@std/assert/1.0.11/false.js

@@ -1,22 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./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.
- */
-export function assertFalse(expr, msg = "") {
-    if (expr) {
-        throw new AssertionError(msg);
-    }
-}

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

@@ -1,23 +0,0 @@
-/** 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/esm/deps/jsr.io/@std/assert/1.0.11/instance_of.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"instance_of.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/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/esm/deps/jsr.io/@std/assert/1.0.11/instance_of.js

@@ -1,53 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./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.
- */
-export 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 AssertionError(msg);
-}

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

@@ -1,25 +0,0 @@
-/**
- * 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/esm/deps/jsr.io/@std/assert/1.0.11/is_error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/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/esm/deps/jsr.io/@std/assert/1.0.11/is_error.js

@@ -1,54 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./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.
- *
- * @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 function assertIsError(error, 
-// deno-lint-ignore no-explicit-any
-ErrorClass, msgMatches, msg) {
-    var _a;
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    if (!(error instanceof Error)) {
-        throw new 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 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 = `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 AssertionError(msg);
-    }
-}

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

@@ -1,18 +0,0 @@
-/**
- * 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/esm/deps/jsr.io/@std/assert/1.0.11/match.d.ts.map

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

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

@@ -1,26 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./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.
- */
-export function assertMatch(actual, expected, msg) {
-    if (expected.test(actual))
-        return;
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    msg = `Expected actual: "${actual}" to match: "${expected}"${msgSuffix}`;
-    throw new AssertionError(msg);
-}

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

@@ -1,20 +0,0 @@
-/**
- * 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/esm/deps/jsr.io/@std/assert/1.0.11/not_instance_of.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"not_instance_of.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/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/esm/deps/jsr.io/@std/assert/1.0.11/not_instance_of.js

@@ -1,29 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { assertFalse } from "./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.
- */
-export 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}`;
-    assertFalse(actual instanceof unexpectedType, msg);
-}

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

@@ -1,18 +0,0 @@
-/**
- * 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/esm/deps/jsr.io/@std/assert/1.0.11/not_match.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"not_match.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/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/esm/deps/jsr.io/@std/assert/1.0.11/not_match.js

@@ -1,26 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./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.
- */
-export 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 AssertionError(msg);
-}