@mtkruto/node 0.0.6

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

@@ -0,0 +1,86 @@
+export default 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
+        });
+    }
+}

package/esm/deps.js

@@ -0,0 +1,4 @@
+export * from "./deps/deno.land/std@0.186.0/testing/asserts.js";
+export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.1.1/mod.js";
+export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js";
+export { Mutex } from "async-mutex";

package/esm/mod.js

@@ -0,0 +1,4 @@
+export * as types from "./tl/2_types.js";
+export * as functions from "./tl/3_functions.js";
+export { ClientPlain } from "./client/client_plain.js";
+export { Client } from "./client/client.js";

package/esm/package.json

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

package/esm/tl/0_tl_raw_reader.js

@@ -0,0 +1,62 @@
+import { bigIntFromBuffer } from "../utilities/0_bigint.js";
+export 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(bigIntFromBuffer(buffer, true, signed));
+    }
+    readInt32(signed = true) {
+        const buffer = this.read(32 / 8);
+        return Number(bigIntFromBuffer(buffer, true, signed));
+    }
+    readInt64(signed = true) {
+        const buffer = this.read(64 / 8);
+        return bigIntFromBuffer(buffer, true, signed);
+    }
+    readInt128(signed = true) {
+        const buffer = this.read(128 / 8);
+        return bigIntFromBuffer(buffer, true, signed);
+    }
+    readInt256(signed = true) {
+        const buffer = this.read(256 / 8);
+        return 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());
+    }
+}

package/esm/tl/0_tl_raw_writer.js

@@ -0,0 +1,60 @@
+import { bufferFromBigInt, concat } from "../utilities/0_buffer.js";
+export 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 = concat(this._buffer, buffer);
+        return this;
+    }
+    writeInt24(int, signed = true) {
+        this.write(bufferFromBigInt(int, 24 / 7, true, signed));
+        return this;
+    }
+    writeInt32(int, signed = true) {
+        this.write(bufferFromBigInt(int, 32 / 8, true, signed));
+        return this;
+    }
+    writeInt64(int, signed = true) {
+        this.write(bufferFromBigInt(int, 64 / 8, true, signed));
+        return this;
+    }
+    writeInt128(int, signed = true) {
+        this.write(bufferFromBigInt(int, 128 / 8, true, signed));
+        return this;
+    }
+    writeInt256(int, signed = true) {
+        this.write(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;
+    }
+}

package/esm/tl/1_tl_object.js

@@ -0,0 +1,149 @@
+import { assertEquals, assertFalse } from "../deps.js";
+import { TLRawWriter } from "./0_tl_raw_writer.js";
+export const flags = Symbol("flags");
+export const id = Symbol("id");
+export const params = Symbol("params");
+export const paramDesc = Symbol("paramDesc");
+export const length = Symbol("length");
+export function isOptionalParam(ntype) {
+    return ntype.includes("?");
+}
+export function analyzeOptionalParam(ntype) {
+    if (!isOptionalParam(ntype)) {
+        throw new Error("Parameter not optional");
+    }
+    const flagField = ntype.split(".")[0];
+    assertEquals(typeof flagField, "string");
+    const bitIndex = Number(ntype.split("?")[0].split(".")[1]);
+    assertFalse(isNaN(bitIndex));
+    return { flagField, bitIndex };
+}
+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");
+            }
+    }
+}
+export class TLObject {
+    static get [paramDesc]() {
+        // unimpl
+        return [];
+    }
+    get [length]() {
+        return this.serialize().byteLength;
+    }
+    serialize() {
+        const writer = new TLRawWriter();
+        writer.writeInt32(this[id], false);
+        for (const [value, type, ntype] of this[params]) {
+            if (isOptionalParam(ntype) && value == null) {
+                continue;
+            }
+            if (type == flags) {
+                let flags = 0;
+                const flagField_ = value;
+                for (const [value, _, ntype] of this[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;
+    }
+}
+export function isTLObjectConstructor(t) {
+    // deno-lint-ignore no-explicit-any
+    return t[paramDesc] instanceof Array;
+}