@mtkruto/node 0.0.971 → 0.0.973

package/esm/deps/deno.land/std@0.196.0/testing/asserts.js

@@ -0,0 +1,330 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/mod.ts` instead.
+ *
+ * A library of assertion functions.
+ * If the assertion is false an `AssertionError` will be thrown which will
+ * result in pretty-printed diff of failing assertion.
+ *
+ * This module is browser compatible, but do not rely on good formatting of
+ * values for AssertionError messages in browsers.
+ *
+ * @module
+ */
+export { 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert.ts` instead.
+ *
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ */
+assert, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_almost_equals.ts` instead.
+ *
+ * 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/testing/asserts.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, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_array_includes.ts` instead.
+ *
+ * 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/testing/asserts.ts";
+ *
+ * assertArrayIncludes<number>([1, 2], [2])
+ * ```
+ */
+assertArrayIncludes, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_equals.ts` instead.
+ *
+ * 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/testing/asserts.ts";
+ *
+ * Deno.test("example", function (): void {
+ *   assertEquals("world", "world");
+ *   assertEquals({ hello: "world" }, { hello: "world" });
+ * });
+ * ```
+ */
+assertEquals, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_exists.ts` instead.
+ *
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+assertExists, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_false.ts` instead.
+ *
+ * Make an assertion, error will be thrown if `expr` have truthy value.
+ */
+assertFalse, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_instance_of.ts` instead.
+ *
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ */
+assertInstanceOf, 
+/** @deprecated (will be removed after 1.0.0) Import from `std/assert/assertion_error.ts` instead. */
+AssertionError, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_is_error.ts` instead.
+ *
+ * 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.
+ */
+assertIsError, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_match.ts` instead.
+ *
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ */
+assertMatch, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_not_equals.ts` instead.
+ *
+ * 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/testing/asserts.ts";
+ *
+ * assertNotEquals<number>(1, 2)
+ * ```
+ */
+assertNotEquals, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_not_instance_of.ts` instead.
+ *
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ */
+assertNotInstanceOf, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_not_match.ts` instead.
+ *
+ * Make an assertion that `actual` object is a subset of `expected` object, deeply.
+ * If not, then throw.
+ */
+assertNotMatch, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_not_strict_equals.ts` instead.
+ *
+ * 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/testing/asserts.ts";
+ *
+ * assertNotStrictEquals(1, 1)
+ * ```
+ */
+assertNotStrictEquals, 
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object, deeply.
+ * If not, then throw.
+ */
+assertObjectMatch, 
+/**
+ * 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/testing/asserts.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");
+ *     },
+ *   );
+ * });
+ * ```
+ *
+ *  * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.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");
+ *     },
+ *   );
+ * });
+ * ```
+ */
+assertRejects, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_strict_equals.ts` instead.
+ *
+ * Make an assertion that `actual` and `expected` are strictly equal. If
+ * not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("isStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = a;
+ *   assertStrictEquals(a, b);
+ * });
+ *
+ * // This test fails
+ * Deno.test("isNotStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = {};
+ *   assertStrictEquals(a, b);
+ * });
+ * ```
+ */
+assertStrictEquals, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_string_includes.ts` instead.
+ *
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ */
+assertStringIncludes, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/assert_throws.ts` instead.
+ *
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws. An error class and a string that should be included in the
+ * error message can also be asserted.
+ *
+ * @example
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", function (): void {
+ *   assertThrows((): void => {
+ *     throw new TypeError("hello world!");
+ *   }, TypeError);
+ *   assertThrows(
+ *     (): void => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *     TypeError,
+ *     "hello",
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", function (): void {
+ *   assertThrows((): void => {
+ *     console.log("Hello world");
+ *   });
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", function (): void {
+ *   assertThrows((): void => {
+ *     throw new TypeError("hello world!");
+ *   });
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", function (): void {
+ *   assertThrows((): void => {
+ *     console.log("Hello world");
+ *   });
+ * });
+ * ```
+ */
+assertThrows, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/equal.ts` instead.
+ *
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ */
+equal, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/fail.ts` instead.
+ *
+ * Forcefully throws a failed assertion
+ */
+fail, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/unimplemented.ts` instead.
+ *
+ * Use this to stub out methods that will throw when invoked.
+ */
+unimplemented, 
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/unreachable.ts` instead.
+ *
+ * Use this to assert unreachable code.
+ */
+unreachable, } from "../assert/mod.js";

package/esm/deps.d.ts

@@ -1,8 +1,8 @@
-export * from "./deps/deno.land/std@0.190.0/testing/asserts.js";
+export * from "./deps/deno.land/std@0.196.0/testing/asserts.js";
 export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.1.3/mod.js";
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js";
 export { Mutex, type MutexInterface } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js";
 export declare const debug: typeof debug_;
-export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.190.0/encoding/base64.js";
+export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.196.0/encoding/base64.js";

package/esm/deps.js

@@ -1,8 +1,8 @@
-export * from "./deps/deno.land/std@0.190.0/testing/asserts.js";
+export * from "./deps/deno.land/std@0.196.0/testing/asserts.js";
 export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.1.3/mod.js";
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js";
 export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js";
 export const debug = (v) => debug_(`mtkruto/${v}`);
-export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.190.0/encoding/base64.js";
+export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.196.0/encoding/base64.js";

package/esm/storage/0_storage.d.ts

@@ -19,7 +19,7 @@ export declare abstract class Storage {
     setUserAccessHash(id: bigint, accessHash: bigint): MaybePromise<void>;
     getUserAccessHash(id: bigint): MaybePromise<bigint | null>;
     updateUsernames(type: "user" | "channel", id: bigint, usernames: string[]): Promise<void>;
-    getUsername(username: string): MaybePromise<["channel" | "user", bigint, Date] | null>;
+    getUsername(username: string): Promise<["channel" | "user", bigint, Date] | null>;
     setTlObject(key: readonly StorageKeyPart[], value: TLObject | null): Promise<void>;
     getTLObject(key: readonly StorageKeyPart[]): Promise<import("../tl/3_tl_reader.js").ReadObject | null>;
     setState(state: types.UpdatesState): Promise<void>;

package/esm/storage/0_storage.js

@@ -71,9 +71,14 @@ export class Storage {
             await this.set(KPARTS__USERNAME(username), [type, String(id), new Date()]);
         }
     }
-    getUsername(username) {
+    async getUsername(username) {
         username = username.toLowerCase();
-        return this.get(KPARTS__USERNAME(username));
+        const v = await this.get(KPARTS__USERNAME(username));
+        if (v != null) {
+            v[1] = BigInt(v[1]);
+            v[2] = new Date(v[2]);
+        }
+        return v;
     }
     async setTlObject(key, value) {
         if (value == null) {

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
   "name": "@mtkruto/node",
-  "version": "0.0.971",
+  "version": "0.0.973",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "license": "LGPL-3.0-or-later",

package/script/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.973";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/script/constants.js

@@ -80,7 +80,7 @@ exports.PUBLIC_KEYS = Object.freeze([
 exports.VECTOR_CONSTRUCTOR = 0x1CB5C415;
 exports.INITIAL_DC = "2-test";
 exports.LAYER = 160;
-exports.APP_VERSION = "MTKruto 0.0.971";
+exports.APP_VERSION = "MTKruto 0.0.973";
 // @ts-ignore: lib
 exports.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;
 exports.LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

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

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

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAN_NOT_DISPLAY = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+exports.CAN_NOT_DISPLAY = "[Cannot display]";

package/script/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/script/deps/deno.land/std@0.196.0/assert/assert.js

@@ -0,0 +1,12 @@
+"use strict";
+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. */
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}
+exports.assert = assert;

package/script/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/script/deps/deno.land/std@0.196.0/assert/assert_almost_equals.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.
+ *
+ * @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));
+ * ```
+ */
+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 assertion_error_js_1.AssertionError(`Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
+delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`);
+}
+exports.assertAlmostEquals = assertAlmostEquals;

package/script/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/script/deps/deno.land/std@0.196.0/assert/assert_array_includes.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArrayIncludes = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+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.
+ *
+ * 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])
+ * ```
+ */
+function assertArrayIncludes(actual, expected, msg) {
+    const missing = [];
+    for (let i = 0; i < expected.length; i++) {
+        let found = false;
+        for (let j = 0; j < actual.length; j++) {
+            if ((0, equal_js_1.equal)(expected[i], actual[j])) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            missing.push(expected[i]);
+        }
+    }
+    if (missing.length === 0) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${(0, _format_js_1.format)(actual)}" to include: "${(0, _format_js_1.format)(expected)}"${msgSuffix}\nmissing: ${(0, _format_js_1.format)(missing)}`;
+    throw new assertion_error_js_1.AssertionError(msg);
+}
+exports.assertArrayIncludes = assertArrayIncludes;

package/script/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/script/deps/deno.land/std@0.196.0/assert/assert_equals.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertEquals = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const equal_js_1 = require("./equal.js");
+const _format_js_1 = require("./_format.js");
+const assertion_error_js_1 = require("./assertion_error.js");
+const colors_js_1 = require("../fmt/colors.js");
+const diff_js_1 = require("../_util/diff.js");
+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.
+ *
+ * @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" });
+ * });
+ * ```
+ */
+function assertEquals(actual, expected, msg) {
+    if ((0, equal_js_1.equal)(actual, expected)) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    let message = `Values are not equal${msgSuffix}`;
+    const actualString = (0, _format_js_1.format)(actual);
+    const expectedString = (0, _format_js_1.format)(expected);
+    try {
+        const stringDiff = (typeof actual === "string") &&
+            (typeof expected === "string");
+        const diffResult = stringDiff
+            ? (0, diff_js_1.diffstr)(actual, expected)
+            : (0, diff_js_1.diff)(actualString.split("\n"), expectedString.split("\n"));
+        const diffMsg = (0, diff_js_1.buildMessage)(diffResult, { stringDiff }).join("\n");
+        message = `${message}\n${diffMsg}`;
+    }
+    catch {
+        message = `${message}\n${(0, colors_js_1.red)(_constants_js_1.CAN_NOT_DISPLAY)} + \n\n`;
+    }
+    throw new assertion_error_js_1.AssertionError(message);
+}
+exports.assertEquals = assertEquals;

package/script/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/script/deps/deno.land/std@0.196.0/assert/assert_exists.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertExists = 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 is not null or undefined.
+ * If not then throw.
+ */
+function assertExists(actual, msg) {
+    if (actual === undefined || actual === null) {
+        const msgSuffix = msg ? `: ${msg}` : ".";
+        msg =
+            `Expected actual: "${actual}" to not be null or undefined${msgSuffix}`;
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}
+exports.assertExists = assertExists;

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

@@ -0,0 +1,11 @@
+"use strict";
+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");
+function assertFalse(expr, msg = "") {
+    if (expr) {
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}
+exports.assertFalse = assertFalse;