@mtkruto/node 0.0.971 → 0.0.972

package/esm/constants.d.ts

@@ -5,7 +5,7 @@ export declare const PUBLIC_KEYS: PublicKeys;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 160;
-export declare const APP_VERSION = "MTKruto 0.0.971";
+export declare const APP_VERSION = "MTKruto 0.0.972";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/constants.js

@@ -54,7 +54,7 @@ export const PUBLIC_KEYS = Object.freeze([
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const INITIAL_DC = "2-test";
 export const LAYER = 160;
-export const APP_VERSION = "MTKruto 0.0.971";
+export const APP_VERSION = "MTKruto 0.0.972";
 // @ts-ignore: lib
 export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/esm/deps/deno.land/std@0.196.0/assert/_constants.d.ts

@@ -0,0 +1 @@
+export declare const CAN_NOT_DISPLAY = "[Cannot display]";

package/esm/deps/deno.land/std@0.196.0/assert/_constants.js

@@ -0,0 +1,2 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export const CAN_NOT_DISPLAY = "[Cannot display]";

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

@@ -0,0 +1,2 @@
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;

package/esm/deps/deno.land/std@0.196.0/assert/assert.js

@@ -0,0 +1,8 @@
+// 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` does not have truthy value. */
+export function assert(expr, msg = "") {
+    if (!expr) {
+        throw new AssertionError(msg);
+    }
+}

package/esm/deps/deno.land/std@0.196.0/assert/assert_almost_equals.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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";
+ *
+ * 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));
+ * ```
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;

package/esm/deps/deno.land/std@0.196.0/assert/assert_almost_equals.js

@@ -0,0 +1,32 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+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.
+ *
+ * @example
+ * ```ts
+ * import { assertAlmostEquals, assertThrows } 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));
+ * ```
+ */
+export function assertAlmostEquals(actual, expected, tolerance = 1e-7, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const delta = Math.abs(expected - actual);
+    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/deno.land/std@0.196.0/assert/assert_array_includes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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<number>([1, 2], [2])
+ * ```
+ */
+export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;

package/esm/deps/deno.land/std@0.196.0/assert/assert_array_includes.js

@@ -0,0 +1,38 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+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.
+ *
+ * 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])
+ * ```
+ */
+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/deno.land/std@0.196.0/assert/assert_equals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ *
+ * @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" });
+ * });
+ * ```
+ */
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;

package/esm/deps/deno.land/std@0.196.0/assert/assert_equals.js

@@ -0,0 +1,45 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { equal } from "./equal.js";
+import { format } from "./_format.js";
+import { AssertionError } from "./assertion_error.js";
+import { red } from "../fmt/colors.js";
+import { buildMessage, diff, diffstr } from "../_util/diff.js";
+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.
+ *
+ * @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" });
+ * });
+ * ```
+ */
+export function assertEquals(actual, expected, msg) {
+    if (equal(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message = `Values are not equal${msgSuffix}`;
+    const actualString = format(actual);
+    const expectedString = format(expected);
+    try {
+        const stringDiff = (typeof actual === "string") &&
+            (typeof expected === "string");
+        const diffResult = stringDiff
+            ? diffstr(actual, expected)
+            : diff(actualString.split("\n"), expectedString.split("\n"));
+        const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
+        message = `${message}\n${diffMsg}`;
+    }
+    catch {
+        message = `${message}\n${red(CAN_NOT_DISPLAY)} + \n\n`;
+    }
+    throw new AssertionError(message);
+}

package/esm/deps/deno.land/std@0.196.0/assert/assert_exists.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;

package/esm/deps/deno.land/std@0.196.0/assert/assert_exists.js

@@ -0,0 +1,14 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+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/deno.land/std@0.196.0/assert/assert_false.d.ts

@@ -0,0 +1,4 @@
+/** Make an assertion, error will be thrown if `expr` have truthy value. */
+type Falsy = false | 0 | 0n | "" | null | undefined;
+export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;
+export {};

package/esm/deps/deno.land/std@0.196.0/assert/assert_false.js

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

package/esm/deps/deno.land/std@0.196.0/assert/assert_instance_of.d.ts

@@ -0,0 +1,8 @@
+type AnyConstructor = new (...args: any[]) => any;
+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.
+ */
+export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is GetConstructorType<T>;
+export {};

package/esm/deps/deno.land/std@0.196.0/assert/assert_instance_of.js

@@ -0,0 +1,38 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ */
+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/deno.land/std@0.196.0/assert/assert_is_error.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): asserts error is E;

package/esm/deps/deno.land/std@0.196.0/assert/assert_is_error.js

@@ -0,0 +1,26 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+import { stripColor } 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.
+ */
+export function assertIsError(error, 
+// deno-lint-ignore no-explicit-any
+ErrorClass, msgIncludes, msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    if (error instanceof Error === false) {
+        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);
+    }
+    if (msgIncludes && (!(error instanceof Error) ||
+        !stripColor(error.message).includes(stripColor(msgIncludes)))) {
+        msg = `Expected error message to include "${msgIncludes}", but got "${error instanceof Error ? error.message : "[not an Error]"}"${msgSuffix}`;
+        throw new AssertionError(msg);
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ */
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;

package/esm/deps/deno.land/std@0.196.0/assert/assert_match.js

@@ -0,0 +1,13 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ */
+export function assertMatch(actual, expected, msg) {
+    if (!expected.test(actual)) {
+        const msgSuffix = msg ? `: ${msg}` : ".";
+        msg = `Expected actual: "${actual}" to match: "${expected}"${msgSuffix}`;
+        throw new AssertionError(msg);
+    }
+}

package/esm/deps/deno.land/std@0.196.0/assert/assert_not_equals.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Make an assertion that `actual` and `expected` are not equal, deeply.
+ * If not then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
+ *
+ * assertNotEquals<number>(1, 2)
+ * ```
+ */
+export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;

package/esm/deps/deno.land/std@0.196.0/assert/assert_not_equals.js

@@ -0,0 +1,37 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { equal } from "./equal.js";
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that `actual` and `expected` are not equal, deeply.
+ * If not then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
+ *
+ * assertNotEquals<number>(1, 2)
+ * ```
+ */
+export function assertNotEquals(actual, expected, msg) {
+    if (!equal(actual, expected)) {
+        return;
+    }
+    let actualString;
+    let expectedString;
+    try {
+        actualString = String(actual);
+    }
+    catch {
+        actualString = "[Cannot display]";
+    }
+    try {
+        expectedString = String(expected);
+    }
+    catch {
+        expectedString = "[Cannot display]";
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Expected actual: ${actualString} not to be: ${expectedString}${msgSuffix}`);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ */
+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.196.0/assert/assert_not_instance_of.js

@@ -0,0 +1,14 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { assertFalse } from "./assert_false.js";
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ */
+export function assertNotInstanceOf(actual, 
+// deno-lint-ignore no-explicit-any
+unexpectedType, msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg =
+        `Expected object to not be an instance of "${typeof unexpectedType}"${msgSuffix}`;
+    assertFalse(actual instanceof unexpectedType, msg);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;

package/esm/deps/deno.land/std@0.196.0/assert/assert_not_match.js

@@ -0,0 +1,14 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ */
+export function assertNotMatch(actual, expected, msg) {
+    if (expected.test(actual)) {
+        const msgSuffix = msg ? `: ${msg}` : ".";
+        msg =
+            `Expected actual: "${actual}" to not match: "${expected}"${msgSuffix}`;
+        throw new AssertionError(msg);
+    }
+}

package/esm/deps/deno.land/std@0.196.0/assert/assert_not_strict_equals.d.ts

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

package/esm/deps/deno.land/std@0.196.0/assert/assert_not_strict_equals.js

@@ -0,0 +1,20 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+import { format } from "./_format.js";
+/**
+ * Make an assertion that `actual` and `expected` are not strictly equal.
+ * If the values are strictly equal then throw.
+ *
+ * ```ts
+ * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_strict_equals.ts";
+ *
+ * assertNotStrictEquals(1, 1)
+ * ```
+ */
+export function assertNotStrictEquals(actual, expected, msg) {
+    if (!Object.is(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Expected "actual" to be strictly unequal to: ${format(actual)}${msgSuffix}\n`);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object, deeply.
+ * If not, then throw.
+ */
+export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;

package/esm/deps/deno.land/std@0.196.0/assert/assert_object_match.js

@@ -0,0 +1,78 @@
+// 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.
+ */
+export function assertObjectMatch(
+// deno-lint-ignore no-explicit-any
+actual, expected, msg) {
+    function filter(a, b) {
+        const seen = new WeakMap();
+        return fn(a, b);
+        function fn(a, b) {
+            // Prevent infinite loop with circular references with same filter
+            if ((seen.has(a)) && (seen.get(a) === b)) {
+                return a;
+            }
+            try {
+                seen.set(a, b);
+            }
+            catch (err) {
+                if (err instanceof TypeError) {
+                    throw new TypeError(`Cannot assertObjectMatch ${a === null ? null : `type ${typeof a}`}`);
+                }
+                else
+                    throw err;
+            }
+            // Filter keys and symbols which are present in both actual and expected
+            const filtered = {};
+            const entries = [
+                ...Object.getOwnPropertyNames(a),
+                ...Object.getOwnPropertySymbols(a),
+            ]
+                .filter((key) => key in b)
+                .map((key) => [key, a[key]]);
+            for (const [key, value] of entries) {
+                // On array references, build a filtered array and filter nested objects inside
+                if (Array.isArray(value)) {
+                    const subset = b[key];
+                    if (Array.isArray(subset)) {
+                        filtered[key] = fn({ ...value }, { ...subset });
+                        continue;
+                    }
+                } // On regexp references, keep value as it to avoid loosing pattern and flags
+                else if (value instanceof RegExp) {
+                    filtered[key] = value;
+                    continue;
+                } // On nested objects references, build a filtered object recursively
+                else if (typeof value === "object" && value !== null) {
+                    const subset = b[key];
+                    if ((typeof subset === "object") && (subset)) {
+                        // When both operands are maps, build a filtered map with common keys and filter nested objects inside
+                        if ((value instanceof Map) && (subset instanceof Map)) {
+                            filtered[key] = new Map([...value].filter(([k]) => subset.has(k)).map(([k, v]) => [k, typeof v === "object" ? fn(v, subset.get(k)) : v]));
+                            continue;
+                        }
+                        // When both operands are set, build a filtered set with common values
+                        if ((value instanceof Set) && (subset instanceof Set)) {
+                            filtered[key] = new Set([...value].filter((v) => subset.has(v)));
+                            continue;
+                        }
+                        filtered[key] = fn(value, subset);
+                        continue;
+                    }
+                }
+                filtered[key] = value;
+            }
+            return filtered;
+        }
+    }
+    return assertEquals(
+    // get the intersection of "actual" and "expected"
+    // side effect: all the instances' constructor field is "Object" now.
+    filter(actual, expected), 
+    // set (nested) instances' constructor field to be "Object" without changing expected value.
+    // see https://github.com/denoland/deno_std/pull/1419
+    filter(expected, expected), msg);
+}

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

@@ -0,0 +1,64 @@
+/**
+ * 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";
+ *
+ * Deno.test("doesThrow", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *   );
+ *   await assertRejects(
+ *     async () => {
+ *       return Promise.reject(new Error());
+ *     },
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       console.log("Hello world");
+ *     },
+ *   );
+ * });
+ * ```
+ */
+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";
+ *
+ * Deno.test("doesThrow", async function () {
+ *   await assertRejects(async () => {
+ *     throw new TypeError("hello world!");
+ *   }, TypeError);
+ *   await assertRejects(
+ *     async () => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *     TypeError,
+ *     "hello",
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       console.log("Hello world");
+ *     },
+ *   );
+ * });
+ * ```
+ */
+export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;