@mtkruto/node 0.63.2 → 0.63.4

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

@@ -1,46 +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` 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 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 AssertionError(`Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
-delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`);
-}

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

@@ -1,46 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { equal } from "./equal.js";
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./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.
- */
-export 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 (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: "${format(actual)}" to include: "${format(expected)}"${msgSuffix}\nmissing: ${format(missing)}`;
-    throw new AssertionError(msg);
-}

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

@@ -1,27 +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 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 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 AssertionError(msg);
-    }
-}

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

@@ -1,20 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./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.
- */
-export function fail(msg) {
-    const msgSuffix = msg ? `: ${msg}` : ".";
-    throw new AssertionError(`Failed assertion${msgSuffix}`);
-}

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

@@ -1,29 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./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.
- */
-export function assertGreater(actual, expected, msg) {
-    if (actual > expected)
-        return;
-    const actualString = format(actual);
-    const expectedString = format(expected);
-    throw new AssertionError(msg ?? `Expect ${actualString} > ${expectedString}`);
-}

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

@@ -1,29 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./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.
- */
-export function assertGreaterOrEqual(actual, expected, msg) {
-    if (actual >= expected)
-        return;
-    const actualString = format(actual);
-    const expectedString = format(expected);
-    throw new AssertionError(msg ?? `Expect ${actualString} >= ${expectedString}`);
-}

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.js

@@ -1,52 +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 = "") {
-    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 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.js

@@ -1,53 +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) {
-    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 "${error?.constructor?.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?.message)}${msgSuffix}`;
-        throw new AssertionError(msg);
-    }
-}

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

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

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

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

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

@@ -1,28 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./assertion_error.js";
-/**
- * Make an assertion that `actual` is less than `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertLess } from "@std/assert";
- *
- * assertLess(1, 2); // Doesn't throw
- * assertLess(2, 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 function assertLess(actual, expected, msg) {
-    if (actual < expected)
-        return;
-    const actualString = format(actual);
-    const expectedString = format(expected);
-    throw new AssertionError(msg ?? `Expect ${actualString} < ${expectedString}`);
-}

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

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

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

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

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

@@ -1,29 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { format } from "../../internal/1.0.5/format.js";
-import { AssertionError } from "./assertion_error.js";
-/**
- * Make an assertion that `actual` is less than or equal to `expected`.
- * If not then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertLessOrEqual } from "@std/assert";
- *
- * assertLessOrEqual(1, 2); // Doesn't throw
- * assertLessOrEqual(1, 1); // Doesn't throw
- * assertLessOrEqual(1, 0); // 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 function assertLessOrEqual(actual, expected, msg) {
-    if (actual <= expected)
-        return;
-    const actualString = format(actual);
-    const expectedString = format(expected);
-    throw new AssertionError(msg ?? `Expect ${actualString} <= ${expectedString}`);
-}

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"}