@mtkruto/node 0.0.6

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/zstream.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ZStream {
+    constructor() {
+        /* next input byte */
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        }); // JS specific, because we have no pointers
+        Object.defineProperty(this, "next_in", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /* number of bytes available at input */
+        Object.defineProperty(this, "avail_in", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /* total number of input bytes read so far */
+        Object.defineProperty(this, "total_in", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /* next output byte should be put there */
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        }); // JS specific, because we have no pointers
+        Object.defineProperty(this, "next_out", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /* remaining free space at output */
+        Object.defineProperty(this, "avail_out", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /* total number of bytes output so far */
+        Object.defineProperty(this, "total_out", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /* last error message, NULL if no error */
+        Object.defineProperty(this, "msg", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "" /*Z_NULL*/
+        });
+        /* not visible by applications */
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /* best guess about the data type: binary or text */
+        Object.defineProperty(this, "data_type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 2 /*Z_UNKNOWN*/
+        });
+        /* adler32 value of the uncompressed data */
+        Object.defineProperty(this, "adler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+}
+exports.default = ZStream;

package/script/deps.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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.186.0/testing/asserts.js"), exports);
+var mod_js_1 = require("./deps/deno.land/x/tgcrypto@0.1.1/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; } });
+Object.defineProperty(exports, "factorize", { enumerable: true, get: function () { return mod_js_1.factorize; } });
+Object.defineProperty(exports, "ige256Decrypt", { enumerable: true, get: function () { return mod_js_1.ige256Decrypt; } });
+Object.defineProperty(exports, "ige256Encrypt", { enumerable: true, get: function () { return mod_js_1.ige256Encrypt; } });
+Object.defineProperty(exports, "initTgCrypto", { enumerable: true, get: function () { return mod_js_1.init; } });
+var gzip_js_1 = require("./deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js");
+Object.defineProperty(exports, "gunzip", { enumerable: true, get: function () { return gzip_js_1.gunzip; } });
+Object.defineProperty(exports, "gzip", { enumerable: true, get: function () { return gzip_js_1.gzip; } });
+var async_mutex_1 = require("async-mutex");
+Object.defineProperty(exports, "Mutex", { enumerable: true, get: function () { return async_mutex_1.Mutex; } });

package/script/mod.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.ClientPlain = exports.functions = exports.types = void 0;
+exports.types = __importStar(require("./tl/2_types.js"));
+exports.functions = __importStar(require("./tl/3_functions.js"));
+var client_plain_js_1 = require("./client/client_plain.js");
+Object.defineProperty(exports, "ClientPlain", { enumerable: true, get: function () { return client_plain_js_1.ClientPlain; } });
+var client_js_1 = require("./client/client.js");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_js_1.Client; } });

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/tl/0_tl_raw_reader.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLRawReader = void 0;
+const _0_bigint_js_1 = require("../utilities/0_bigint.js");
+class TLRawReader {
+    constructor(_buffer) {
+        Object.defineProperty(this, "_buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _buffer
+        });
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    read(count) {
+        if (this._buffer.length < count) {
+            throw new Error("No data remaining");
+        }
+        const buffer = this._buffer.slice(0, count);
+        this._buffer = this._buffer.slice(count);
+        return buffer;
+    }
+    readInt24(signed = true) {
+        const buffer = this.read(24 / 8);
+        return Number((0, _0_bigint_js_1.bigIntFromBuffer)(buffer, true, signed));
+    }
+    readInt32(signed = true) {
+        const buffer = this.read(32 / 8);
+        return Number((0, _0_bigint_js_1.bigIntFromBuffer)(buffer, true, signed));
+    }
+    readInt64(signed = true) {
+        const buffer = this.read(64 / 8);
+        return (0, _0_bigint_js_1.bigIntFromBuffer)(buffer, true, signed);
+    }
+    readInt128(signed = true) {
+        const buffer = this.read(128 / 8);
+        return (0, _0_bigint_js_1.bigIntFromBuffer)(buffer, true, signed);
+    }
+    readInt256(signed = true) {
+        const buffer = this.read(256 / 8);
+        return (0, _0_bigint_js_1.bigIntFromBuffer)(buffer, true, signed);
+    }
+    readBytes() {
+        let L = this.read(1)[0];
+        let padding;
+        if (L > 253) {
+            L = this.readInt24();
+            padding = L % 4;
+        }
+        else {
+            padding = (L + 1) % 4;
+        }
+        const bytes = this.read(L);
+        if (padding > 0) {
+            padding = 4 - padding;
+            this.read(padding);
+        }
+        return bytes;
+    }
+    readString() {
+        return new TextDecoder().decode(this.readBytes());
+    }
+}
+exports.TLRawReader = TLRawReader;

package/script/tl/0_tl_raw_writer.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLRawWriter = void 0;
+const _0_buffer_js_1 = require("../utilities/0_buffer.js");
+class TLRawWriter {
+    constructor() {
+        Object.defineProperty(this, "_buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Uint8Array()
+        });
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    write(buffer) {
+        this._buffer = (0, _0_buffer_js_1.concat)(this._buffer, buffer);
+        return this;
+    }
+    writeInt24(int, signed = true) {
+        this.write((0, _0_buffer_js_1.bufferFromBigInt)(int, 24 / 7, true, signed));
+        return this;
+    }
+    writeInt32(int, signed = true) {
+        this.write((0, _0_buffer_js_1.bufferFromBigInt)(int, 32 / 8, true, signed));
+        return this;
+    }
+    writeInt64(int, signed = true) {
+        this.write((0, _0_buffer_js_1.bufferFromBigInt)(int, 64 / 8, true, signed));
+        return this;
+    }
+    writeInt128(int, signed = true) {
+        this.write((0, _0_buffer_js_1.bufferFromBigInt)(int, 128 / 8, true, signed));
+        return this;
+    }
+    writeInt256(int, signed = true) {
+        this.write((0, _0_buffer_js_1.bufferFromBigInt)(int, 256 / 8, true, signed));
+        return this;
+    }
+    writeBytes(bytes) {
+        let padding;
+        if (bytes.length > 253) {
+            this.write(new Uint8Array([254]));
+            this.writeInt24(bytes.length);
+            padding = bytes.length % 4;
+        }
+        else {
+            this.write(new Uint8Array([bytes.length]));
+            padding = (bytes.length + 1) % 4;
+        }
+        this.write(bytes);
+        if (padding > 0) {
+            padding = 4 - padding;
+            this.write(new Uint8Array(padding));
+        }
+        return this;
+    }
+    writeString(string) {
+        this.writeBytes(new TextEncoder().encode(string));
+        return this;
+    }
+}
+exports.TLRawWriter = TLRawWriter;

package/script/tl/1_tl_object.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTLObjectConstructor = exports.TLObject = exports.analyzeOptionalParam = exports.isOptionalParam = exports.length = exports.paramDesc = exports.params = exports.id = exports.flags = void 0;
+const deps_js_1 = require("../deps.js");
+const _0_tl_raw_writer_js_1 = require("./0_tl_raw_writer.js");
+exports.flags = Symbol("flags");
+exports.id = Symbol("id");
+exports.params = Symbol("params");
+exports.paramDesc = Symbol("paramDesc");
+exports.length = Symbol("length");
+function isOptionalParam(ntype) {
+    return ntype.includes("?");
+}
+exports.isOptionalParam = isOptionalParam;
+function analyzeOptionalParam(ntype) {
+    if (!isOptionalParam(ntype)) {
+        throw new Error("Parameter not optional");
+    }
+    const flagField = ntype.split(".")[0];
+    (0, deps_js_1.assertEquals)(typeof flagField, "string");
+    const bitIndex = Number(ntype.split("?")[0].split(".")[1]);
+    (0, deps_js_1.assertFalse)(isNaN(bitIndex));
+    return { flagField, bitIndex };
+}
+exports.analyzeOptionalParam = analyzeOptionalParam;
+function serializeSingleParam(writer, value, type, ntype) {
+    if (isTLObjectConstructor(type)) {
+        if ((type.name == "TypeX" && value instanceof TLObject) ||
+            value instanceof type) {
+            writer.write(value.serialize());
+            return;
+        }
+        else {
+            throw new Error("a");
+        }
+    }
+    if (type == Uint8Array) {
+        if ((value instanceof Uint8Array)) {
+            writer.writeBytes(value);
+        }
+        else {
+            throw new Error("Expected Uint8Array");
+        }
+    }
+    switch (type) {
+        case "bigint":
+            if (typeof value === "bigint") {
+                if (ntype == "int128") {
+                    writer.writeInt128(value);
+                }
+                else if (ntype === "int256") {
+                    writer.writeInt256(value);
+                }
+                else {
+                    writer.writeInt64(value);
+                }
+            }
+            else {
+                throw new Error("Expected bigint");
+            }
+            break;
+        case "boolean":
+            if (typeof value === "boolean") {
+                if (value) {
+                    writer.writeInt32(0x997275B5);
+                }
+                else {
+                    writer.writeInt32(0xBC799737);
+                }
+            }
+            else {
+                throw new Error("Expected boolean");
+            }
+            break;
+        case "number":
+            if (typeof value === "number") {
+                writer.writeInt32(value);
+            }
+            else {
+                throw new Error("Expected number");
+            }
+            break;
+        case "string":
+            if (typeof value === "string") {
+                writer.writeString(value);
+            }
+            else if (value instanceof Uint8Array) {
+                writer.writeBytes(value);
+            }
+            else {
+                throw new Error("Expected string or Uint8Array");
+            }
+            break;
+        case "true":
+            if (value === true) {
+                writer.writeInt32(0x997275B5);
+            }
+            else {
+                throw new Error("Expected true");
+            }
+    }
+}
+class TLObject {
+    static get [exports.paramDesc]() {
+        // unimpl
+        return [];
+    }
+    get [exports.length]() {
+        return this.serialize().byteLength;
+    }
+    serialize() {
+        const writer = new _0_tl_raw_writer_js_1.TLRawWriter();
+        writer.writeInt32(this[exports.id], false);
+        for (const [value, type, ntype] of this[exports.params]) {
+            if (isOptionalParam(ntype) && value == null) {
+                continue;
+            }
+            if (type == exports.flags) {
+                let flags = 0;
+                const flagField_ = value;
+                for (const [value, _, ntype] of this[exports.params]) {
+                    if (isOptionalParam(ntype)) {
+                        const { flagField, bitIndex } = analyzeOptionalParam(ntype);
+                        if (flagField == flagField_) {
+                            if (value != null) {
+                                flags |= 1 << bitIndex;
+                            }
+                        }
+                    }
+                }
+                writer.writeInt32(flags);
+                continue;
+            }
+            if (type instanceof Array) {
+                const itemsType = type[0];
+                if (!Array.isArray(value)) {
+                    throw new Error("Expected array");
+                }
+                writer.writeInt32(0x1CB5C415); // vector constructor
+                writer.writeInt32(value.length);
+                for (const item of value) {
+                    serializeSingleParam(writer, item, itemsType, ntype);
+                }
+                continue;
+            }
+            serializeSingleParam(writer, value, type, ntype);
+        }
+        return writer.buffer;
+    }
+}
+exports.TLObject = TLObject;
+function isTLObjectConstructor(t) {
+    // deno-lint-ignore no-explicit-any
+    return t[exports.paramDesc] instanceof Array;
+}
+exports.isTLObjectConstructor = isTLObjectConstructor;