@mtkruto/node 0.0.970 → 0.0.972

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

@@ -0,0 +1,333 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unreachable = exports.unimplemented = exports.fail = exports.equal = exports.assertThrows = exports.assertStringIncludes = exports.assertStrictEquals = exports.assertRejects = exports.assertObjectMatch = exports.assertNotStrictEquals = exports.assertNotMatch = exports.assertNotInstanceOf = exports.assertNotEquals = exports.assertMatch = exports.assertIsError = exports.AssertionError = exports.assertInstanceOf = exports.assertFalse = exports.assertExists = exports.assertEquals = exports.assertArrayIncludes = exports.assertAlmostEquals = exports.assert = void 0;
+/**
+ * @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
+ */
+var mod_js_1 = require("../assert/mod.js");
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return mod_js_1.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));
+ * ```
+ */
+Object.defineProperty(exports, "assertAlmostEquals", { enumerable: true, get: function () { return mod_js_1.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])
+ * ```
+ */
+Object.defineProperty(exports, "assertArrayIncludes", { enumerable: true, get: function () { return mod_js_1.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" });
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "assertEquals", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "assertExists", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "assertFalse", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "assertInstanceOf", { enumerable: true, get: function () { return mod_js_1.assertInstanceOf; } });
+/** @deprecated (will be removed after 1.0.0) Import from `std/assert/assertion_error.ts` instead. */
+Object.defineProperty(exports, "AssertionError", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "assertIsError", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "assertMatch", { enumerable: true, get: function () { return mod_js_1.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)
+ * ```
+ */
+Object.defineProperty(exports, "assertNotEquals", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "assertNotInstanceOf", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "assertNotMatch", { enumerable: true, get: function () { return mod_js_1.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)
+ * ```
+ */
+Object.defineProperty(exports, "assertNotStrictEquals", { enumerable: true, get: function () { return mod_js_1.assertNotStrictEquals; } });
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object, deeply.
+ * If not, then throw.
+ */
+Object.defineProperty(exports, "assertObjectMatch", { enumerable: true, get: function () { return mod_js_1.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");
+ *     },
+ *   );
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "assertRejects", { enumerable: true, get: function () { return mod_js_1.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);
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "assertStrictEquals", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "assertStringIncludes", { enumerable: true, get: function () { return mod_js_1.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");
+ *   });
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "assertThrows", { enumerable: true, get: function () { return mod_js_1.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
+ */
+Object.defineProperty(exports, "equal", { enumerable: true, get: function () { return mod_js_1.equal; } });
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/fail.ts` instead.
+ *
+ * Forcefully throws a failed assertion
+ */
+Object.defineProperty(exports, "fail", { enumerable: true, get: function () { return mod_js_1.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.
+ */
+Object.defineProperty(exports, "unimplemented", { enumerable: true, get: function () { return mod_js_1.unimplemented; } });
+/**
+ * @deprecated (will be removed after 1.0.0) Import from `std/assert/unreachable.ts` instead.
+ *
+ * Use this to assert unreachable code.
+ */
+Object.defineProperty(exports, "unreachable", { enumerable: true, get: function () { return mod_js_1.unreachable; } });

package/script/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/script/deps.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.base64Encode = exports.base64Decode = exports.debug = exports.Parser = exports.Mutex = exports.gzip = exports.gunzip = exports.initTgCrypto = exports.ige256Encrypt = exports.ige256Decrypt = exports.factorize = exports.ctr256Encrypt = exports.ctr256Decrypt = void 0;
-__exportStar(require("./deps/deno.land/std@0.190.0/testing/asserts.js"), exports);
+__exportStar(require("./deps/deno.land/std@0.196.0/testing/asserts.js"), exports);
 var mod_js_1 = require("./deps/deno.land/x/tgcrypto@0.1.3/mod.js");
 Object.defineProperty(exports, "ctr256Decrypt", { enumerable: true, get: function () { return mod_js_1.ctr256Decrypt; } });
 Object.defineProperty(exports, "ctr256Encrypt", { enumerable: true, get: function () { return mod_js_1.ctr256Encrypt; } });
@@ -33,6 +33,6 @@ Object.defineProperty(exports, "Parser", { enumerable: true, get: function () {
 const mod_js_3 = require("./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js");
 const debug = (v) => (0, mod_js_3.debug)(`mtkruto/${v}`);
 exports.debug = debug;
-var base64_js_1 = require("./deps/deno.land/std@0.190.0/encoding/base64.js");
+var base64_js_1 = require("./deps/deno.land/std@0.196.0/encoding/base64.js");
 Object.defineProperty(exports, "base64Decode", { enumerable: true, get: function () { return base64_js_1.decode; } });
 Object.defineProperty(exports, "base64Encode", { enumerable: true, get: function () { return base64_js_1.encode; } });

package/script/tl/1_tl_object.js

@@ -123,7 +123,7 @@ class TLObject {
             if (isOptionalParam(ntype) && value == null) {
                 continue;
             }
-            const debugInfo = `[${i}]`;
+            const debugInfo = `[${this[exports.id].toString(16).toUpperCase()} ${i}]`;
             if (type == exports.flags) {
                 let flags = 0;
                 const flagField_ = value;