@mtkruto/node 0.1.125 → 0.1.127

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

@@ -3,16 +3,18 @@ import { equal } from "./equal.js";
 import { format } from "./_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.
+ * 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
  * ```
  */
 export function assertArrayIncludes(actual, expected, msg) {

package/{script/deps/deno.land/std@0.208.0 → esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_equals.js

@@ -9,16 +9,15 @@ import { CAN_NOT_DISPLAY } from "./_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/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_exists.js

@@ -3,6 +3,14 @@ import { AssertionError } from "./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
+ * ```
  */
 export function assertExists(actual, msg) {
     if (actual === undefined || actual === null) {

package/esm/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/esm/deps/deno.land/std@0.209.0/assert/assert_false.js

@@ -0,0 +1,18 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * 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 function assertFalse(expr, msg = "") {
+    if (expr) {
+        throw new AssertionError(msg);
+    }
+}

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_greater.js

@@ -4,6 +4,15 @@ import { AssertionError } from "./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
+ * ```
  */
 export function assertGreater(actual, expected, msg) {
     if (actual > expected)

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_greater_or_equal.js

@@ -4,6 +4,15 @@ import { AssertionError } from "./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
+ * ```
  */
 export function assertGreaterOrEqual(actual, expected, msg) {
     if (actual >= expected)

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_instance_of.js

@@ -3,6 +3,14 @@ import { AssertionError } from "./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
+ * ```
  */
 export function assertInstanceOf(actual, expectedType, msg = "") {
     if (actual instanceof expectedType)

package/esm/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/esm/deps/deno.land/std@0.209.0/assert/assert_is_error.js

@@ -0,0 +1,48 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+import { stripAnsiCode } from "../fmt/colors.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
+ * ```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 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 "${typeof error === "object" ? error?.constructor?.name : "[not an object]"}"${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 ${error instanceof Error
+            ? JSON.stringify(error.message)
+            : '"[not an Error]"' // TODO(kt3k): show more useful information
+        }${msgSuffix}`;
+        throw new AssertionError(msg);
+    }
+}

package/esm/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/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_less.js

@@ -4,6 +4,14 @@ import { AssertionError } from "./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
+ * ```
  */
 export function assertLess(actual, expected, msg) {
     if (actual < expected)

package/esm/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;

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

@@ -4,6 +4,15 @@ import { AssertionError } from "./assertion_error.js";
 /**
  * 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 function assertLessOrEqual(actual, expected, msg) {
     if (actual <= expected)

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

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_match.ts";
+ *
+ * assertMatch("Raptor", RegExp(/Raptor/)); // Doesn't throw
+ * assertMatch("Denosaurus", RegExp(/Raptor/)); // Throws
+ * ```
+ */
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;

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

@@ -3,6 +3,14 @@ import { AssertionError } from "./assertion_error.js";
 /**
  * Make an assertion that `actual` match RegExp `expected`. If not
  * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_match.ts";
+ *
+ * assertMatch("Raptor", RegExp(/Raptor/)); // Doesn't throw
+ * assertMatch("Denosaurus", RegExp(/Raptor/)); // Throws
+ * ```
  */
 export function assertMatch(actual, expected, msg) {
     if (!expected.test(actual)) {

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

@@ -8,7 +8,8 @@
  * ```ts
  * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
  *
- * assertNotEquals<number>(1, 2)
+ * assertNotEquals(1, 2); // Doesn't throw
+ * assertNotEquals(1, 1); // Throws
  * ```
  */
 export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;

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

@@ -11,7 +11,8 @@ import { AssertionError } from "./assertion_error.js";
  * ```ts
  * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
  *
- * assertNotEquals<number>(1, 2)
+ * assertNotEquals(1, 2); // Doesn't throw
+ * assertNotEquals(1, 1); // Throws
  * ```
  */
 export function assertNotEquals(actual, expected, msg) {

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

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertNotInstanceOf } from "https://deno.land/std@$STD_VERSION/assert/assert_not_instance_of.ts";
+ *
+ * assertNotInstanceOf(new Date(), Number); // Doesn't throw
+ * assertNotInstanceOf(new Date(), Date); // Throws
+ * ```
+ */
+export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;

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

@@ -3,6 +3,14 @@ import { assertFalse } from "./assert_false.js";
 /**
  * Make an assertion that `obj` is not an instance of `type`.
  * If so, then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertNotInstanceOf } from "https://deno.land/std@$STD_VERSION/assert/assert_not_instance_of.ts";
+ *
+ * assertNotInstanceOf(new Date(), Number); // Doesn't throw
+ * assertNotInstanceOf(new Date(), Date); // Throws
+ * ```
  */
 export function assertNotInstanceOf(actual, 
 // deno-lint-ignore no-explicit-any

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

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertNotMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_not_match.ts";
+ *
+ * assertNotMatch("Denosaurus", RegExp(/Raptor/)); // Doesn't throw
+ * assertNotMatch("Raptor", RegExp(/Raptor/)); // Throws
+ * ```
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;

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

@@ -3,6 +3,14 @@ import { AssertionError } from "./assertion_error.js";
 /**
  * Make an assertion that `actual` not match RegExp `expected`. If match
  * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertNotMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_not_match.ts";
+ *
+ * assertNotMatch("Denosaurus", RegExp(/Raptor/)); // Doesn't throw
+ * assertNotMatch("Raptor", RegExp(/Raptor/)); // Throws
+ * ```
  */
 export function assertNotMatch(actual, expected, msg) {
     if (expected.test(actual)) {

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

@@ -2,10 +2,12 @@
  * Make an assertion that `actual` and `expected` are not strictly equal.
  * If the values are strictly equal then throw.
  *
+ * @example
  * ```ts
  * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_strict_equals.ts";
  *
- * assertNotStrictEquals(1, 1)
+ * assertNotStrictEquals(1, 1); // Doesn't throw
+ * assertNotStrictEquals(1, 2); // Throws
  * ```
  */
 export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;

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

@@ -5,10 +5,12 @@ import { format } from "./_format.js";
  * Make an assertion that `actual` and `expected` are not strictly equal.
  * If the values are strictly equal then throw.
  *
+ * @example
  * ```ts
  * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_strict_equals.ts";
  *
- * assertNotStrictEquals(1, 1)
+ * assertNotStrictEquals(1, 1); // Doesn't throw
+ * assertNotStrictEquals(1, 2); // Throws
  * ```
  */
 export function assertNotStrictEquals(actual, expected, msg) {

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

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object,
+ * deeply. If not, then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertObjectMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_object_match.ts";
+ *
+ * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
+ * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
+ * ```
+ */
+export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;

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

@@ -1,8 +1,16 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 import { assertEquals } from "./assert_equals.js";
 /**
- * Make an assertion that `actual` object is a subset of `expected` object, deeply.
- * If not, then throw.
+ * Make an assertion that `actual` object is a subset of `expected` object,
+ * deeply. If not, then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertObjectMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_object_match.ts";
+ *
+ * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
+ * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
+ * ```
  */
 export function assertObjectMatch(
 // deno-lint-ignore no-explicit-any

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

@@ -0,0 +1,26 @@
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ *
+ * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts";
+ *
+ * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
+ * await assertRejects(async () => console.log("Hello world")); // Throws
+ * ```
+ */
+export declare function assertRejects(fn: () => PromiseLike<unknown>, msg?: string): Promise<unknown>;
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ * 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.
+ *
+ * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts";
+ *
+ * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
+ * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
+ * ```
+ */
+export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;

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

@@ -6,18 +6,13 @@
  * ```ts
  * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_strict_equals.ts";
  *
- * Deno.test("isStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = a;
- *   assertStrictEquals(a, b);
- * });
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
  *
- * // This test fails
- * Deno.test("isNotStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = {};
- *   assertStrictEquals(a, b);
- * });
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
  * ```
  */
 export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;

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

@@ -12,18 +12,13 @@ import { red } from "../fmt/colors.js";
  * ```ts
  * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_strict_equals.ts";
  *
- * Deno.test("isStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = a;
- *   assertStrictEquals(a, b);
- * });
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
  *
- * // This test fails
- * Deno.test("isNotStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = {};
- *   assertStrictEquals(a, b);
- * });
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
  * ```
  */
 export function assertStrictEquals(actual, expected, msg) {

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

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStringIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_string_includes.ts";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;