@mtkruto/node 0.63.3 → 0.63.6

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

@@ -1,18 +0,0 @@
-/**
- * Make an assertion that actual includes expected. If not
- * then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertStringIncludes } from "@std/assert";
- *
- * assertStringIncludes("Hello", "ello"); // Doesn't throw
- * assertStringIncludes("Hello", "world"); // Throws
- * ```
- *
- * @param actual The actual string to check for inclusion.
- * @param expected The expected string to check for inclusion.
- * @param msg The optional message to display if the assertion fails.
- */
-export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
-//# sourceMappingURL=string_includes.d.ts.map

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

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

package/esm/deps/jsr.io/@std/assert/1.0.11/string_includes.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 includes expected. If not
- * then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertStringIncludes } from "@std/assert";
- *
- * assertStringIncludes("Hello", "ello"); // Doesn't throw
- * assertStringIncludes("Hello", "world"); // Throws
- * ```
- *
- * @param actual The actual string to check for inclusion.
- * @param expected The expected string to check for inclusion.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertStringIncludes(actual, expected, msg) {
-    if (actual.includes(expected))
-        return;
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    msg = `Expected actual: "${actual}" to contain: "${expected}"${msgSuffix}`;
-    throw new AssertionError(msg);
-}

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

@@ -1,45 +0,0 @@
-/**
- * Executes a function, expecting it to throw. If it does not, then it
- * throws.
- *
- * To assert that an asynchronous function rejects, use
- * {@linkcode assertRejects}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertThrows } from "@std/assert";
- *
- * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
- * assertThrows(() => console.log("hello world!")); // Throws
- * ```
- *
- * @param fn The function to execute.
- * @param msg The optional message to display if the assertion fails.
- * @returns The error that was thrown.
- */
-export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
-/**
- * Executes a function, expecting it to throw. If it does not, then it
- * throws. An error class and a string that should be included in the
- * error message can also be asserted.
- *
- * To assert that an asynchronous function rejects, use
- * {@linkcode assertRejects}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertThrows } from "@std/assert";
- *
- * assertThrows(() => { throw new TypeError("hello world!"); }, TypeError); // Doesn't throw
- * assertThrows(() => { throw new TypeError("hello world!"); }, RangeError); // Throws
- * ```
- *
- * @typeParam E The error class to assert.
- * @param fn The function to execute.
- * @param ErrorClass The error class to assert.
- * @param msgIncludes The string that should be included in the error message.
- * @param msg The optional message to display if the assertion fails.
- * @returns The error that was thrown.
- */
-export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: abstract new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
-//# sourceMappingURL=throws.d.ts.map

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

@@ -1,44 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { assertIsError } from "./is_error.js";
-import { AssertionError } from "./assertion_error.js";
-export function assertThrows(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
-    // deno-lint-ignore no-explicit-any
-    let ErrorClass;
-    let msgIncludes;
-    let err;
-    if (typeof errorClassOrMsg !== "string") {
-        if (errorClassOrMsg === undefined ||
-            errorClassOrMsg?.prototype instanceof Error ||
-            errorClassOrMsg?.prototype === Error.prototype) {
-            ErrorClass = errorClassOrMsg;
-            msgIncludes = msgIncludesOrMsg;
-        }
-        else {
-            msg = msgIncludesOrMsg;
-        }
-    }
-    else {
-        msg = errorClassOrMsg;
-    }
-    let doesThrow = false;
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    try {
-        fn();
-    }
-    catch (error) {
-        if (ErrorClass) {
-            if (error instanceof Error === false) {
-                throw new AssertionError(`A non-Error object was thrown${msgSuffix}`);
-            }
-            assertIsError(error, ErrorClass, msgIncludes, msg);
-        }
-        err = error;
-        doesThrow = true;
-    }
-    if (!doesThrow) {
-        msg = `Expected function to throw${msgSuffix}`;
-        throw new AssertionError(msg);
-    }
-    return err;
-}

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

@@ -1,15 +0,0 @@
-/**
- * Use this to stub out methods that will throw when invoked.
- *
- * @example Usage
- * ```ts ignore
- * import { unimplemented } from "@std/assert";
- *
- * unimplemented(); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export declare function unimplemented(msg?: string): never;
-//# sourceMappingURL=unimplemented.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"unimplemented.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/unimplemented.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAGjD"}

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

@@ -1,20 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-/**
- * Use this to stub out methods that will throw when invoked.
- *
- * @example Usage
- * ```ts ignore
- * import { unimplemented } from "@std/assert";
- *
- * unimplemented(); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export function unimplemented(msg) {
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    throw new AssertionError(`Unimplemented${msgSuffix}`);
-}

package/script/deps/jsr.io/@std/assert/1.0.11/almost_equals.d.ts

@@ -1,29 +0,0 @@
-/**
- * Make an assertion that `actual` and `expected` are almost equal numbers
- * through a given tolerance. It can be used to take into account IEEE-754
- * double-precision floating-point representation limitations. If the values
- * are not almost equal then throw.
- *
- * The default tolerance is one hundred thousandth of a percent of the
- * expected value.
- *
- * @example Usage
- * ```ts ignore
- * import { assertAlmostEquals } from "@std/assert";
- *
- * assertAlmostEquals(0.01, 0.02); // Throws
- * assertAlmostEquals(1e-8, 1e-9); // Throws
- * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
- * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
- * ```
- *
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param tolerance The tolerance to consider the values almost equal. The
- * default is one hundred thousandth of a percent of the expected value.
- * @param msg The optional message to include in the error.
- */
-export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
-//# sourceMappingURL=almost_equals.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.11/almost_equals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"almost_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/almost_equals.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,GAAG,CAAC,EAAE,MAAM,QAmBb"}

package/script/deps/jsr.io/@std/assert/1.0.11/almost_equals.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertAlmostEquals = assertAlmostEquals;
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-const assertion_error_js_1 = require("./assertion_error.js");
-/**
- * Make an assertion that `actual` and `expected` are almost equal numbers
- * through a given tolerance. It can be used to take into account IEEE-754
- * double-precision floating-point representation limitations. If the values
- * are not almost equal then throw.
- *
- * The default tolerance is one hundred thousandth of a percent of the
- * expected value.
- *
- * @example Usage
- * ```ts ignore
- * import { assertAlmostEquals } from "@std/assert";
- *
- * assertAlmostEquals(0.01, 0.02); // Throws
- * assertAlmostEquals(1e-8, 1e-9); // Throws
- * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
- * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
- * ```
- *
- * @param actual The actual value to compare.
- * @param expected The expected value to compare.
- * @param tolerance The tolerance to consider the values almost equal. The
- * default is one hundred thousandth of a percent of the expected value.
- * @param msg The optional message to include in the error.
- */
-function assertAlmostEquals(actual, expected, tolerance, msg) {
-    if (Object.is(actual, expected)) {
-        return;
-    }
-    const delta = Math.abs(expected - actual);
-    if (tolerance === undefined) {
-        tolerance = isFinite(expected) ? Math.abs(expected * 1e-7) : 1e-7;
-    }
-    if (delta <= tolerance) {
-        return;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    const f = (n) => Number.isInteger(n) ? n : n.toExponential();
-    throw new assertion_error_js_1.AssertionError(`Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
-delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`);
-}

package/script/deps/jsr.io/@std/assert/1.0.11/array_includes.d.ts

@@ -1,24 +0,0 @@
-/** An array-like object (`Array`, `Uint8Array`, `NodeList`, etc.) that is not a string */
-export type ArrayLikeArg<T> = ArrayLike<T> & object;
-/**
- * Make an assertion that `actual` includes the `expected` values. If not then
- * an error will be thrown.
- *
- * Type parameter can be specified to ensure values under comparison have the
- * same type.
- *
- * @example Usage
- * ```ts ignore
- * import { assertArrayIncludes } from "@std/assert";
- *
- * assertArrayIncludes([1, 2], [2]); // Doesn't throw
- * assertArrayIncludes([1, 2], [3]); // Throws
- * ```
- *
- * @typeParam T The type of the elements in the array to compare.
- * @param actual The array-like object to check for.
- * @param expected The array-like object to check for.
- * @param msg The optional message to display if the assertion fails.
- */
-export declare function assertArrayIncludes<T>(actual: ArrayLikeArg<T>, expected: ArrayLikeArg<T>, msg?: string): void;
-//# sourceMappingURL=array_includes.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.11/array_includes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array_includes.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/array_includes.ts"],"names":[],"mappings":"AAMA,0FAA0F;AAC1F,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,GAAG,CAAC,EAAE,MAAM,QAwBb"}

package/script/deps/jsr.io/@std/assert/1.0.11/array_includes.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertArrayIncludes = assertArrayIncludes;
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-const equal_js_1 = require("./equal.js");
-const format_js_1 = require("../../internal/1.0.6/format.js");
-const assertion_error_js_1 = require("./assertion_error.js");
-/**
- * Make an assertion that `actual` includes the `expected` values. If not then
- * an error will be thrown.
- *
- * Type parameter can be specified to ensure values under comparison have the
- * same type.
- *
- * @example Usage
- * ```ts ignore
- * import { assertArrayIncludes } from "@std/assert";
- *
- * assertArrayIncludes([1, 2], [2]); // Doesn't throw
- * assertArrayIncludes([1, 2], [3]); // Throws
- * ```
- *
- * @typeParam T The type of the elements in the array to compare.
- * @param actual The array-like object to check for.
- * @param expected The array-like object to check for.
- * @param msg The optional message to display if the assertion fails.
- */
-function assertArrayIncludes(actual, expected, msg) {
-    const missing = [];
-    for (let i = 0; i < expected.length; i++) {
-        let found = false;
-        for (let j = 0; j < actual.length; j++) {
-            if ((0, equal_js_1.equal)(expected[i], actual[j])) {
-                found = true;
-                break;
-            }
-        }
-        if (!found) {
-            missing.push(expected[i]);
-        }
-    }
-    if (missing.length === 0) {
-        return;
-    }
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    msg = `Expected actual: "${(0, format_js_1.format)(actual)}" to include: "${(0, format_js_1.format)(expected)}"${msgSuffix}\nmissing: ${(0, format_js_1.format)(missing)}`;
-    throw new assertion_error_js_1.AssertionError(msg);
-}

package/script/deps/jsr.io/@std/assert/1.0.11/exists.d.ts

@@ -1,18 +0,0 @@
-/**
- * Make an assertion that actual is not null or undefined.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertExists } from "@std/assert";
- *
- * assertExists("something"); // Doesn't throw
- * assertExists(undefined); // Throws
- * ```
- *
- * @typeParam T The type of the actual value.
- * @param actual The actual value to check.
- * @param msg The optional message to include in the error if the assertion fails.
- */
-export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
-//# sourceMappingURL=exists.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.11/exists.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/exists.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC,CAOlC"}

package/script/deps/jsr.io/@std/assert/1.0.11/exists.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertExists = assertExists;
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-const assertion_error_js_1 = require("./assertion_error.js");
-/**
- * Make an assertion that actual is not null or undefined.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertExists } from "@std/assert";
- *
- * assertExists("something"); // Doesn't throw
- * assertExists(undefined); // Throws
- * ```
- *
- * @typeParam T The type of the actual value.
- * @param actual The actual value to check.
- * @param msg The optional message to include in the error if the assertion fails.
- */
-function assertExists(actual, msg) {
-    if (actual === undefined || actual === null) {
-        const msgSuffix = msg ? `: ${msg}` : ".";
-        msg =
-            `Expected actual: "${actual}" to not be null or undefined${msgSuffix}`;
-        throw new assertion_error_js_1.AssertionError(msg);
-    }
-}

package/script/deps/jsr.io/@std/assert/1.0.11/fail.d.ts

@@ -1,15 +0,0 @@
-/**
- * Forcefully throws a failed assertion.
- *
- * @example Usage
- * ```ts ignore
- * import { fail } from "@std/assert";
- *
- * fail("Deliberately failed!"); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export declare function fail(msg?: string): never;
-//# sourceMappingURL=fail.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.11/fail.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/fail.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAGxC"}

package/script/deps/jsr.io/@std/assert/1.0.11/fail.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fail = fail;
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-const assertion_error_js_1 = require("./assertion_error.js");
-/**
- * Forcefully throws a failed assertion.
- *
- * @example Usage
- * ```ts ignore
- * import { fail } from "@std/assert";
- *
- * fail("Deliberately failed!"); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-function fail(msg) {
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    throw new assertion_error_js_1.AssertionError(`Failed assertion${msgSuffix}`);
-}

package/script/deps/jsr.io/@std/assert/1.0.11/greater.d.ts

@@ -1,20 +0,0 @@
-/**
- * Make an assertion that `actual` is greater than `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertGreater } from "@std/assert";
- *
- * assertGreater(2, 1); // Doesn't throw
- * assertGreater(1, 1); // Throws
- * assertGreater(0, 1); // Throws
- * ```
- *
- * @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 assertGreater<T>(actual: T, expected: T, msg?: string): void;
-//# sourceMappingURL=greater.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.11/greater.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"greater.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/greater.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,QAMpE"}

package/script/deps/jsr.io/@std/assert/1.0.11/greater.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertGreater = assertGreater;
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-const format_js_1 = require("../../internal/1.0.6/format.js");
-const assertion_error_js_1 = require("./assertion_error.js");
-/**
- * Make an assertion that `actual` is greater than `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertGreater } from "@std/assert";
- *
- * assertGreater(2, 1); // Doesn't throw
- * assertGreater(1, 1); // Throws
- * assertGreater(0, 1); // Throws
- * ```
- *
- * @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.
- */
-function assertGreater(actual, expected, msg) {
-    if (actual > expected)
-        return;
-    const actualString = (0, format_js_1.format)(actual);
-    const expectedString = (0, format_js_1.format)(expected);
-    throw new assertion_error_js_1.AssertionError(msg ?? `Expect ${actualString} > ${expectedString}`);
-}

package/script/deps/jsr.io/@std/assert/1.0.11/greater_or_equal.d.ts

@@ -1,20 +0,0 @@
-/**
- * Make an assertion that `actual` is greater than or equal to `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertGreaterOrEqual } from "@std/assert";
- *
- * assertGreaterOrEqual(2, 1); // Doesn't throw
- * assertGreaterOrEqual(1, 1); // Doesn't throw
- * assertGreaterOrEqual(0, 1); // Throws
- * ```
- *
- * @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 assertGreaterOrEqual<T>(actual: T, expected: T, msg?: string): void;
-//# sourceMappingURL=greater_or_equal.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.11/greater_or_equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"greater_or_equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/greater_or_equal.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QASb"}

package/script/deps/jsr.io/@std/assert/1.0.11/greater_or_equal.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertGreaterOrEqual = assertGreaterOrEqual;
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-const format_js_1 = require("../../internal/1.0.6/format.js");
-const assertion_error_js_1 = require("./assertion_error.js");
-/**
- * Make an assertion that `actual` is greater than or equal to `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertGreaterOrEqual } from "@std/assert";
- *
- * assertGreaterOrEqual(2, 1); // Doesn't throw
- * assertGreaterOrEqual(1, 1); // Doesn't throw
- * assertGreaterOrEqual(0, 1); // Throws
- * ```
- *
- * @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.
- */
-function assertGreaterOrEqual(actual, expected, msg) {
-    if (actual >= expected)
-        return;
-    const actualString = (0, format_js_1.format)(actual);
-    const expectedString = (0, format_js_1.format)(expected);
-    throw new assertion_error_js_1.AssertionError(msg ?? `Expect ${actualString} >= ${expectedString}`);
-}

package/script/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/script/deps/jsr.io/@std/assert/1.0.11/instance_of.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertInstanceOf = assertInstanceOf;
-// Copyright 2018-2025 the Deno authors. 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 = "") {
-    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 = actual.constructor?.name ?? "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);
-}