@mtkruto/node 0.0.6

package/script/deps/deno.land/x/crc32@v0.2.0/mod.js

@@ -0,0 +1,113 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Crc32Stream_crc32;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint8ArrayToHex = exports.hexToUint8Array = exports.numberToHex = exports.Crc32Stream = exports.crc32 = void 0;
+function crc32(arr) {
+    if (typeof arr === "string") {
+        arr = new TextEncoder().encode(arr);
+    }
+    let crc = -1, i, j, l, temp, poly = 0xEDB88320;
+    for (i = 0, l = arr.length; i < l; i += 1) {
+        temp = (crc ^ arr[i]) & 0xff;
+        for (j = 0; j < 8; j += 1) {
+            if ((temp & 1) === 1) {
+                temp = (temp >>> 1) ^ poly;
+            }
+            else {
+                temp = (temp >>> 1);
+            }
+        }
+        crc = (crc >>> 8) ^ temp;
+    }
+    return numberToHex(crc ^ -1);
+}
+exports.crc32 = crc32;
+class Crc32Stream {
+    constructor() {
+        Object.defineProperty(this, "bytes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "poly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0xEDB88320
+        });
+        Object.defineProperty(this, "crc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0 ^ -1
+        });
+        Object.defineProperty(this, "encoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new TextEncoder()
+        });
+        _Crc32Stream_crc32.set(this, "");
+        this.reset();
+    }
+    get crc32() {
+        return __classPrivateFieldGet(this, _Crc32Stream_crc32, "f");
+    }
+    reset() {
+        __classPrivateFieldSet(this, _Crc32Stream_crc32, "", "f");
+        this.crc = 0 ^ -1;
+        for (let n = 0; n < 256; n += 1) {
+            let c = n;
+            for (let k = 0; k < 8; k += 1) {
+                if (c & 1) {
+                    c = this.poly ^ (c >>> 1);
+                }
+                else {
+                    c = c >>> 1;
+                }
+            }
+            this.bytes[n] = c >>> 0;
+        }
+    }
+    append(arr) {
+        if (typeof arr === "string") {
+            arr = this.encoder.encode(arr);
+        }
+        let crc = this.crc;
+        for (let i = 0, l = arr.length; i < l; i += 1) {
+            crc = (crc >>> 8) ^ this.bytes[(crc ^ arr[i]) & 0xff];
+        }
+        this.crc = crc;
+        __classPrivateFieldSet(this, _Crc32Stream_crc32, numberToHex(crc ^ -1), "f");
+        return __classPrivateFieldGet(this, _Crc32Stream_crc32, "f");
+    }
+}
+exports.Crc32Stream = Crc32Stream;
+_Crc32Stream_crc32 = new WeakMap();
+function numberToHex(n) {
+    return (n >>> 0).toString(16);
+}
+exports.numberToHex = numberToHex;
+function hexToUint8Array(str) {
+    if (str.length === 0 || str.length % 2 !== 0) {
+        throw new Error(`The string "${str}" is not valid hex.`);
+    }
+    return new Uint8Array(str.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+}
+exports.hexToUint8Array = hexToUint8Array;
+function uint8ArrayToHex(bytes) {
+    return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+}
+exports.uint8ArrayToHex = uint8ArrayToHex;

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

@@ -0,0 +1,82 @@
+"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.ctr256Decrypt = exports.ctr256Encrypt = 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;
+/**
+ * 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) {
+    return module_.ige256Encrypt(data, key, iv);
+}
+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) {
+    return module_.ige256Decrypt(data, key, iv);
+}
+exports.ige256Decrypt = ige256Decrypt;
+/**
+ * Performs CTR-256 encryption.
+ *
+ * @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 ctr256Encrypt(data, key, iv, state) {
+    return module_.ctr256Encrypt(data, key, iv, state);
+}
+exports.ctr256Encrypt = ctr256Encrypt;
+/**
+ * Alias of `ctr256Encrypt`
+ */
+function ctr256Decrypt(data, key, iv, state) {
+    return module_.ctr256Decrypt(data, key, iv, state);
+}
+exports.ctr256Decrypt = ctr256Decrypt;
+/**
+ * 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) {
+    return module_.cbc256Encrypt(data, key, iv);
+}
+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) {
+    return module_.cbc256Decrypt(data, key, iv);
+}
+exports.cbc256Decrypt = cbc256Decrypt;
+function factorize(pq) {
+    const vector = module_.factorize(pq);
+    return [vector.get(0), vector.get(1)];
+}
+exports.factorize = factorize;