@mtkruto/browser 0.1.0 → 0.1.101

package/script/deps/deno.land/{std@0.201.0 → std@0.203.0}/fmt/colors.js

@@ -536,7 +536,7 @@ exports.bgRgb24 = bgRgb24;
 // https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
 const ANSI_PATTERN = new RegExp([
     "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
-    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
 ].join("|"), "g");
 /**
  * @deprecated (will be removed in 1.0.0) Use `stripAnsiCode` instead.

package/{esm/deps/deno.land/x/tgcrypto@0.2.1 → script/deps/deno.land/x/tgcrypto@0.3.3}/mod.d.ts

@@ -16,18 +16,14 @@ export declare function ige256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uin
  */
 export declare function ige256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
 /**
- * Performs CTR-256 encryption.
+ * Performs CTR-256 encryption/decryption.
  *
  * @param data The data, larger than a byte
  * @param key 32-byte encryption key
  * @param iv 16-byte initialization vector
  * @param state 1-byte state
  */
-export declare function ctr256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array];
-/**
- * Alias of `ctr256Encrypt`
- */
-export declare function ctr256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array];
+export declare function ctr256(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): void;
 /**
  * Performs CBC-256 encryption.
  *

package/script/deps/deno.land/x/tgcrypto@0.3.3/mod.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorize = exports.cbc256Decrypt = exports.cbc256Encrypt = exports.ctr256 = exports.ige256Decrypt = exports.ige256Encrypt = exports.init = void 0;
+const tgcrypto_js_1 = __importDefault(require("./tgcrypto.js"));
+// deno-lint-ignore no-explicit-any
+let module_;
+const promise = (0, tgcrypto_js_1.default)().then((v) => module_ = v);
+async function init() {
+    await promise;
+}
+exports.init = init;
+function checkIgeParams(data, key, iv) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (data.length % 16 != 0) {
+        throw new TypeError("data must consist of a number of bytes that is divisible by 16");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 32) {
+        throw new TypeError("iv must be 32 bytes");
+    }
+}
+/**
+ * Performs IGE-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+function ige256Encrypt(data, key, iv) {
+    checkIgeParams(data, key, iv);
+    const out = module_._malloc(data.length);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("ige256_encrypt", "void", ["pointer", "pointer", "number", "array", "array"], [datap, out, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(out, out + data.length);
+    }
+    finally {
+        module_._free(out);
+        module_._free(datap);
+    }
+}
+exports.ige256Encrypt = ige256Encrypt;
+/**
+ * Performs IGE-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+function ige256Decrypt(data, key, iv) {
+    checkIgeParams(data, key, iv);
+    const out = module_._malloc(data.length);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("ige256_decrypt", "void", ["pointer", "pointer", "number", "array", "array"], [datap, out, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(out, out + data.length);
+    }
+    finally {
+        module_._free(out);
+        module_._free(datap);
+    }
+}
+exports.ige256Decrypt = ige256Decrypt;
+function checkCtrParams(data, key, iv, state) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 16) {
+        throw new TypeError("iv must be 16 bytes");
+    }
+    else if (state.length != 1) {
+        throw new TypeError("state must be 1 byte");
+    }
+}
+/**
+ * Performs CTR-256 encryption/decryption.
+ *
+ * @param data The data, larger than a byte
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ * @param state 1-byte state
+ */
+function ctr256(data, key, iv, state) {
+    checkCtrParams(data, key, iv, state);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    const ivp = module_._malloc(iv.length);
+    module_.HEAPU8.set(iv, ivp);
+    const statep = module_._malloc(state.length);
+    module_.HEAPU8.set(state, statep);
+    module_.ccall("ctr256", "void", ["pointer", "number", "array", "pointer", "pointer"], [datap, data.length, key, ivp, statep]);
+    data.set(module_.HEAPU8.slice(datap, datap + data.length));
+    iv.set(module_.HEAPU8.slice(ivp, ivp + iv.length));
+    state.set(module_.HEAPU8.slice(statep, statep + state.length));
+    module_._free(datap);
+    module_._free(ivp);
+    module_._free(statep);
+}
+exports.ctr256 = ctr256;
+function checkCbcParams(data, key, iv) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (data.length % 16 != 0) {
+        throw new TypeError("data must consist of a number of bytes that is divisible by 16");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 16) {
+        throw new TypeError("iv must be 16 bytes");
+    }
+}
+/**
+ * Performs CBC-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+function cbc256Encrypt(data, key, iv) {
+    checkCbcParams(data, key, iv);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("cbc256_encrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(datap, datap + data.length);
+    }
+    finally {
+        module_._free(datap);
+    }
+}
+exports.cbc256Encrypt = cbc256Encrypt;
+/**
+ * Performs CBC-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+function cbc256Decrypt(data, key, iv) {
+    checkCbcParams(data, key, iv);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("cbc256_decrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(datap, datap + data.length);
+    }
+    finally {
+        module_._free(datap);
+    }
+}
+exports.cbc256Decrypt = cbc256Decrypt;
+function factorize(pq) {
+    const pqp = module_._malloc(16);
+    module_.ccall("factorize", "void", ["number", "pointer"], [pq, pqp]);
+    try {
+        const pqp_ = module_.HEAP64.slice(pqp / 8, pqp / 8 + 2);
+        return [pqp_[0], pqp_[1]];
+    }
+    finally {
+        module_._free(pqp);
+    }
+}
+exports.factorize = factorize;