@mtkruto/node 0.1.124 → 0.1.126

package/script/connection/0_connection.d.ts

@@ -5,6 +5,10 @@ declare abstract class Foundation {
     abstract open(): MaybePromise<void>;
     abstract write(p: Uint8Array): MaybePromise<void>;
     abstract close(): MaybePromise<void>;
+    callback?: {
+        read(count: number): void;
+        write(count: number): void;
+    };
 }
 export declare abstract class ConnectionUnframed extends Foundation {
     readonly type: "framed";

package/script/connection/0_connection.js

@@ -9,6 +9,12 @@ class Foundation {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
     }
 }
 class ConnectionUnframed extends Foundation {

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/_diff.d.ts

@@ -1,8 +1,9 @@
-export declare enum DiffType {
-    removed = "removed",
-    common = "common",
-    added = "added"
-}
+export declare const DiffType: {
+    readonly removed: "removed";
+    readonly common: "common";
+    readonly added: "added";
+};
+export type DiffType = keyof typeof DiffType;
 export interface DiffResult<T> {
     type: DiffType;
     value: T;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/_diff.js

@@ -4,12 +4,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildMessage = exports.diffstr = exports.diff = exports.DiffType = void 0;
 const colors_js_1 = require("../fmt/colors.js");
-var DiffType;
-(function (DiffType) {
-    DiffType["removed"] = "removed";
-    DiffType["common"] = "common";
-    DiffType["added"] = "added";
-})(DiffType || (exports.DiffType = DiffType = {}));
+exports.DiffType = {
+    removed: "removed",
+    common: "common",
+    added: "added",
+};
 const REMOVED = 1;
 const COMMON = 2;
 const ADDED = 3;
@@ -49,12 +48,12 @@ function diff(A, B) {
         return [];
     if (!N) {
         return [
-            ...prefixCommon.map((c) => ({ type: DiffType.common, value: c })),
+            ...prefixCommon.map((c) => ({ type: exports.DiffType.common, value: c })),
             ...A.map((a) => ({
-                type: swapped ? DiffType.added : DiffType.removed,
+                type: swapped ? exports.DiffType.added : exports.DiffType.removed,
                 value: a,
             })),
-            ...suffixCommon.map((c) => ({ type: DiffType.common, value: c })),
+            ...suffixCommon.map((c) => ({ type: exports.DiffType.common, value: c })),
         ];
     }
     const offset = N;
@@ -87,20 +86,20 @@ function diff(A, B) {
             const prev = j;
             if (type === REMOVED) {
                 result.unshift({
-                    type: swapped ? DiffType.removed : DiffType.added,
+                    type: swapped ? exports.DiffType.removed : exports.DiffType.added,
                     value: B[b],
                 });
                 b -= 1;
             }
             else if (type === ADDED) {
                 result.unshift({
-                    type: swapped ? DiffType.added : DiffType.removed,
+                    type: swapped ? exports.DiffType.added : exports.DiffType.removed,
                     value: A[a],
                 });
                 a -= 1;
             }
             else {
-                result.unshift({ type: DiffType.common, value: A[a] });
+                result.unshift({ type: exports.DiffType.common, value: A[a] });
                 a -= 1;
                 b -= 1;
             }
@@ -157,9 +156,9 @@ function diff(A, B) {
         fp[delta + offset] = snake(delta, fp[delta - 1 + offset], fp[delta + 1 + offset], offset, A, B);
     }
     return [
-        ...prefixCommon.map((c) => ({ type: DiffType.common, value: c })),
+        ...prefixCommon.map((c) => ({ type: exports.DiffType.common, value: c })),
         ...backTrace(A, B, fp[delta + offset], swapped),
-        ...suffixCommon.map((c) => ({ type: DiffType.common, value: c })),
+        ...suffixCommon.map((c) => ({ type: exports.DiffType.common, value: c })),
     ];
 }
 exports.diff = diff;
@@ -220,8 +219,8 @@ function diffstr(A, B) {
     // Create details by filtering relevant word-diff for current line
     // and merge "space-diff" if surrounded by word-diff for cleaner displays
     function createDetails(line, tokens) {
-        return tokens.filter(({ type }) => type === line.type || type === DiffType.common).map((result, i, t) => {
-            if ((result.type === DiffType.common) && (t[i - 1]) &&
+        return tokens.filter(({ type }) => type === line.type || type === exports.DiffType.common).map((result, i, t) => {
+            if ((result.type === exports.DiffType.common) && (t[i - 1]) &&
                 (t[i - 1]?.type === t[i + 1]?.type) && /\s+/.test(result.value)) {
                 return {
                     ...result,
@@ -235,10 +234,10 @@ function diffstr(A, B) {
     const diffResult = diff(tokenize(`${unescape(A)}\n`), tokenize(`${unescape(B)}\n`));
     const added = [], removed = [];
     for (const result of diffResult) {
-        if (result.type === DiffType.added) {
+        if (result.type === exports.DiffType.added) {
             added.push(result);
         }
-        if (result.type === DiffType.removed) {
+        if (result.type === exports.DiffType.removed) {
             removed.push(result);
         }
     }
@@ -258,7 +257,7 @@ function diffstr(A, B) {
             if (hasMoreRemovedLines)
                 tokenized.reverse();
             tokens = diff(tokenized[0], tokenized[1]);
-            if (tokens.some(({ type, value }) => type === DiffType.common && value.trim().length)) {
+            if (tokens.some(({ type, value }) => type === exports.DiffType.common && value.trim().length)) {
                 break;
             }
         }
@@ -281,9 +280,9 @@ function createColor(diffType, { background = false } = {}) {
     // https://github.com/denoland/deno_std/issues/2575
     background = false;
     switch (diffType) {
-        case DiffType.added:
+        case exports.DiffType.added:
             return (s) => background ? (0, colors_js_1.bgGreen)((0, colors_js_1.white)(s)) : (0, colors_js_1.green)((0, colors_js_1.bold)(s));
-        case DiffType.removed:
+        case exports.DiffType.removed:
             return (s) => background ? (0, colors_js_1.bgRed)((0, colors_js_1.white)(s)) : (0, colors_js_1.red)((0, colors_js_1.bold)(s));
         default:
             return colors_js_1.white;
@@ -295,9 +294,9 @@ function createColor(diffType, { background = false } = {}) {
  */
 function createSign(diffType) {
     switch (diffType) {
-        case DiffType.added:
+        case exports.DiffType.added:
             return "+   ";
-        case DiffType.removed:
+        case exports.DiffType.removed:
             return "-   ";
         default:
             return "    ";
@@ -312,7 +311,7 @@ function buildMessage(diffResult, { stringDiff = false } = {}) {
     messages.push("");
     diffResult.forEach((result) => {
         const c = createColor(result.type);
-        const line = result.details?.map((detail) => detail.type !== DiffType.common
+        const line = result.details?.map((detail) => detail.type !== exports.DiffType.common
             ? createColor(detail.type, { background: true })(detail.value)
             : detail.value).join("") ?? result.value;
         diffMessages.push(c(`${createSign(result.type)}${line}`));

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/_format.js

@@ -26,6 +26,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = void 0;
+// This file been copied to `std/expect`.
 /**
  * Converts the input into a string. Objects, Sets and Maps are sorted so as to
  * make tests less flaky
@@ -44,6 +45,7 @@ function format(v) {
             iterableLimit: Infinity,
             // getters should be true in assertEquals.
             getters: true,
+            strAbbreviateSize: Infinity,
         })
         : `"${String(v).replace(/(?=["\\])/g, "\\")}"`;
 }

package/script/deps/deno.land/std@0.209.0/assert/assert.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ */
+export declare function assert(expr: unknown, msg?: string): asserts expr;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert.js

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assert = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 const assertion_error_js_1 = require("./assertion_error.js");
-/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ */
 function assert(expr, msg = "") {
     if (!expr) {
         throw new assertion_error_js_1.AssertionError(msg);

package/script/deps/deno.land/std@0.209.0/assert/assert_almost_equals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * import { assertAlmostEquals } from "https://deno.land/std@$STD_VERSION/assert/mod.ts";
+ *
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_almost_equals.js

@@ -4,20 +4,19 @@ exports.assertAlmostEquals = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 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.
+ * 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.
  *
  * @example
  * ```ts
- * import { assertAlmostEquals, assertThrows } from "https://deno.land/std@$STD_VERSION/assert/mod.ts";
+ * import { assertAlmostEquals } from "https://deno.land/std@$STD_VERSION/assert/mod.ts";
  *
- * assertAlmostEquals(0.1, 0.2);
- *
- * // Using a custom tolerance value
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16);
- * assertThrows(() => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17));
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
  * ```
  */
 function assertAlmostEquals(actual, expected, tolerance = 1e-7, msg) {

package/script/deps/deno.land/std@0.209.0/assert/assert_array_includes.d.ts

@@ -0,0 +1,18 @@
+/** 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
+ * ```ts
+ * import { assertArrayIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_array_includes.ts";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ */
+export declare function assertArrayIncludes<T>(actual: ArrayLikeArg<T>, expected: ArrayLikeArg<T>, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_array_includes.js

@@ -6,16 +6,18 @@ const equal_js_1 = require("./equal.js");
 const _format_js_1 = require("./_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.
+ * 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.
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
  *
  * @example
  * ```ts
  * import { assertArrayIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_array_includes.ts";
  *
- * assertArrayIncludes<number>([1, 2], [2])
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
  * ```
  */
 function assertArrayIncludes(actual, expected, msg) {

package/{esm/deps/deno.land/std@0.208.0 → script/deps/deno.land/std@0.209.0}/assert/assert_equals.d.ts

@@ -2,16 +2,15 @@
  * 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.
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
  *
  * @example
  * ```ts
  * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
  *
- * Deno.test("example", function (): void {
- *   assertEquals("world", "world");
- *   assertEquals({ hello: "world" }, { hello: "world" });
- * });
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
  * ```
  *
  * Note: formatter option is experimental and may be removed in the future.

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_equals.js

@@ -12,16 +12,15 @@ const _constants_js_1 = require("./_constants.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.
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
  *
  * @example
  * ```ts
  * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
  *
- * Deno.test("example", function (): void {
- *   assertEquals("world", "world");
- *   assertEquals({ hello: "world" }, { hello: "world" });
- * });
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
  * ```
  *
  * Note: formatter option is experimental and may be removed in the future.

package/script/deps/deno.land/std@0.209.0/assert/assert_exists.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertExists } from "https://deno.land/std@$STD_VERSION/assert/assert_exists.ts";
+ *
+ * assertExists("something"); // Doesn't throw
+ * assertExists(undefined); // Throws
+ * ```
+ */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_exists.js

@@ -6,6 +6,14 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that actual is not null or undefined.
  * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertExists } from "https://deno.land/std@$STD_VERSION/assert/assert_exists.ts";
+ *
+ * assertExists("something"); // Doesn't throw
+ * assertExists(undefined); // Throws
+ * ```
  */
 function assertExists(actual, msg) {
     if (actual === undefined || actual === null) {

package/script/deps/deno.land/std@0.209.0/assert/assert_false.d.ts

@@ -0,0 +1,14 @@
+/** 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
+ * ```ts
+ * import { assertFalse } from "https://deno.land/std@$STD_VERSION/assert/assert_false.ts";
+ *
+ * assertFalse(false); // Doesn't throw
+ * assertFalse(true); // Throws
+ * ```
+ */
+export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_false.js

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertFalse = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 const assertion_error_js_1 = require("./assertion_error.js");
-/** Make an assertion, error will be thrown if `expr` have truthy value. */
+/**
+ * Make an assertion, error will be thrown if `expr` have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assertFalse } from "https://deno.land/std@$STD_VERSION/assert/assert_false.ts";
+ *
+ * assertFalse(false); // Doesn't throw
+ * assertFalse(true); // Throws
+ * ```
+ */
 function assertFalse(expr, msg = "") {
     if (expr) {
         throw new assertion_error_js_1.AssertionError(msg);

package/script/deps/deno.land/std@0.209.0/assert/assert_greater.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Make an assertion that `actual` is greater than `expected`.
+ * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertGreater } from "https://deno.land/std@$STD_VERSION/assert/assert_greater.ts";
+ *
+ * assertGreater(2, 1); // Doesn't throw
+ * assertGreater(1, 1); // Throws
+ * assertGreater(0, 1); // Throws
+ * ```
+ */
+export declare function assertGreater<T>(actual: T, expected: T, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_greater.js

@@ -7,6 +7,15 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that `actual` is greater than `expected`.
  * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertGreater } from "https://deno.land/std@$STD_VERSION/assert/assert_greater.ts";
+ *
+ * assertGreater(2, 1); // Doesn't throw
+ * assertGreater(1, 1); // Throws
+ * assertGreater(0, 1); // Throws
+ * ```
  */
 function assertGreater(actual, expected, msg) {
     if (actual > expected)

package/script/deps/deno.land/std@0.209.0/assert/assert_greater_or_equal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Make an assertion that `actual` is greater than or equal to `expected`.
+ * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertGreaterOrEqual } from "https://deno.land/std@$STD_VERSION/assert/assert_greater_or_equal.ts";
+ *
+ * assertGreaterOrEqual(2, 1); // Doesn't throw
+ * assertGreaterOrEqual(1, 1); // Doesn't throw
+ * assertGreaterOrEqual(0, 1); // Throws
+ * ```
+ */
+export declare function assertGreaterOrEqual<T>(actual: T, expected: T, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_greater_or_equal.js

@@ -7,6 +7,15 @@ 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
+ * ```ts
+ * import { assertGreaterOrEqual } from "https://deno.land/std@$STD_VERSION/assert/assert_greater_or_equal.ts";
+ *
+ * assertGreaterOrEqual(2, 1); // Doesn't throw
+ * assertGreaterOrEqual(1, 1); // Doesn't throw
+ * assertGreaterOrEqual(0, 1); // Throws
+ * ```
  */
 function assertGreaterOrEqual(actual, expected, msg) {
     if (actual >= expected)

package/script/deps/deno.land/std@0.209.0/assert/assert_instance_of.d.ts

@@ -0,0 +1,17 @@
+/** Any constructor */
+export type AnyConstructor = new (...args: any[]) => any;
+/** Gets constructor type */
+export type GetConstructorType<T extends AnyConstructor> = T extends new (...args: any) => infer C ? C : never;
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertInstanceOf } from "https://deno.land/std@$STD_VERSION/assert/assert_instance_of.ts";
+ *
+ * assertInstanceOf(new Date(), Date); // Doesn't throw
+ * assertInstanceOf(new Date(), Number); // Throws
+ * ```
+ */
+export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is GetConstructorType<T>;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_instance_of.js

@@ -6,6 +6,14 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that `obj` is an instance of `type`.
  * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertInstanceOf } from "https://deno.land/std@$STD_VERSION/assert/assert_instance_of.ts";
+ *
+ * assertInstanceOf(new Date(), Date); // Doesn't throw
+ * assertInstanceOf(new Date(), Number); // Throws
+ * ```
  */
 function assertInstanceOf(actual, expectedType, msg = "") {
     if (actual instanceof expectedType)

package/script/deps/deno.land/std@0.209.0/assert/assert_is_error.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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
+ * ```ts
+ * import { assertIsError } from "https://deno.land/std@$STD_VERSION/assert/assert_is_error.ts";
+ *
+ * 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
+ * ```
+ */
+export declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E, msgMatches?: string | RegExp, msg?: string): asserts error is E;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_is_error.js

@@ -9,21 +9,40 @@ const colors_js_1 = require("../fmt/colors.js");
  * 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
+ * ```ts
+ * import { assertIsError } from "https://deno.land/std@$STD_VERSION/assert/assert_is_error.ts";
+ *
+ * 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
+ * ```
  */
 function assertIsError(error, 
 // deno-lint-ignore no-explicit-any
-ErrorClass, msgIncludes, msg) {
+ErrorClass, msgMatches, msg) {
     const msgSuffix = msg ? `: ${msg}` : ".";
-    if (error instanceof Error === false) {
+    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 "${typeof error === "object" ? error?.constructor?.name : "[not an object]"}"${msgSuffix}`;
         throw new assertion_error_js_1.AssertionError(msg);
     }
-    if (msgIncludes && (!(error instanceof Error) ||
-        !(0, colors_js_1.stripColor)(error.message).includes((0, colors_js_1.stripColor)(msgIncludes)))) {
-        msg = `Expected error message to include ${JSON.stringify(msgIncludes)}, but got ${error instanceof Error
+    let msgCheck;
+    if (typeof msgMatches === "string") {
+        msgCheck = (0, colors_js_1.stripAnsiCode)(error.message).includes((0, colors_js_1.stripAnsiCode)(msgMatches));
+    }
+    if (msgMatches instanceof RegExp) {
+        msgCheck = msgMatches.test((0, colors_js_1.stripAnsiCode)(error.message));
+    }
+    if (msgMatches && !msgCheck) {
+        msg = `Expected error message to include ${msgMatches instanceof RegExp
+            ? msgMatches.toString()
+            : JSON.stringify(msgMatches)}, but got ${error instanceof Error
             ? JSON.stringify(error.message)
             : '"[not an Error]"' // TODO(kt3k): show more useful information
         }${msgSuffix}`;

package/script/deps/deno.land/std@0.209.0/assert/assert_less.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that `actual` is less than `expected`.
+ * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertLess } from "https://deno.land/std@$STD_VERSION/assert/assert_less.ts";
+ *
+ * assertLess(1, 2); // Doesn't throw
+ * assertLess(2, 1); // Throws
+ * ```
+ */
+export declare function assertLess<T>(actual: T, expected: T, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_less.js

@@ -7,6 +7,14 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that `actual` is less than `expected`.
  * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertLess } from "https://deno.land/std@$STD_VERSION/assert/assert_less.ts";
+ *
+ * assertLess(1, 2); // Doesn't throw
+ * assertLess(2, 1); // Throws
+ * ```
  */
 function assertLess(actual, expected, msg) {
     if (actual < expected)

package/script/deps/deno.land/std@0.209.0/assert/assert_less_or_equal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Make an assertion that `actual` is less than or equal to `expected`.
+ * If not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertLessOrEqual } from "https://deno.land/std@$STD_VERSION/assert/assert_less_or_equal.ts";
+ *
+ * assertLessOrEqual(1, 2); // Doesn't throw
+ * assertLessOrEqual(1, 1); // Doesn't throw
+ * assertLessOrEqual(1, 0); // Throws
+ * ```
+ */
+export declare function assertLessOrEqual<T>(actual: T, expected: T, msg?: string): void;