teleproto 203.0.0

package/extensions/PromisedNetSockets.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { ProxyInterface } from "../network/connection/TCPMTProxy";
+export declare class PromisedNetSockets {
+    private client?;
+    private closed;
+    private stream;
+    private canRead?;
+    private resolveRead;
+    private proxy?;
+    constructor(proxy?: ProxyInterface);
+    readExactly(number: number): Promise<Buffer>;
+    read(number: number): Promise<Buffer>;
+    readAll(): Promise<Buffer>;
+    /**
+     * Creates a new connection
+     * @param port
+     * @param ip
+     * @returns {Promise<void>}
+     */
+    connect(port: number, ip: string): Promise<unknown>;
+    write(data: Buffer): void;
+    close(): Promise<void>;
+    receive(): Promise<void>;
+    toString(): string;
+}

package/extensions/PromisedNetSockets.js

@@ -0,0 +1,178 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.PromisedNetSockets = void 0;
+const net = __importStar(require("./net"));
+const socks_1 = require("./socks");
+const async_mutex_1 = require("async-mutex");
+const mutex = new async_mutex_1.Mutex();
+const closeError = new Error("NetSocket was closed");
+class PromisedNetSockets {
+    constructor(proxy) {
+        this.client = undefined;
+        this.closed = true;
+        this.stream = Buffer.alloc(0);
+        if (proxy) {
+            // we only want to use this when it's not an MTProto proxy.
+            if (!("MTProxy" in proxy)) {
+                if (!proxy.ip || !proxy.port || !proxy.socksType) {
+                    throw new Error(`Invalid sockets params: ip=${proxy.ip}, port=${proxy.port}, socksType=${proxy.socksType}`);
+                }
+                this.proxy = proxy;
+            }
+        }
+    }
+    async readExactly(number) {
+        let readData = Buffer.alloc(0);
+        while (true) {
+            const thisTime = await this.read(number);
+            readData = Buffer.concat([readData, thisTime]);
+            number = number - thisTime.length;
+            if (!number || number === -437) {
+                return readData;
+            }
+        }
+    }
+    async read(number) {
+        if (this.closed) {
+            throw closeError;
+        }
+        await this.canRead;
+        if (this.closed) {
+            throw closeError;
+        }
+        const toReturn = this.stream.slice(0, number);
+        this.stream = this.stream.slice(number);
+        if (this.stream.length === 0) {
+            this.canRead = new Promise((resolve) => {
+                this.resolveRead = resolve;
+            });
+        }
+        return toReturn;
+    }
+    async readAll() {
+        if (this.closed || !(await this.canRead)) {
+            throw closeError;
+        }
+        const toReturn = this.stream;
+        this.stream = Buffer.alloc(0);
+        this.canRead = new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+        return toReturn;
+    }
+    /**
+     * Creates a new connection
+     * @param port
+     * @param ip
+     * @returns {Promise<void>}
+     */
+    async connect(port, ip) {
+        this.stream = Buffer.alloc(0);
+        let connected = false;
+        if (this.proxy) {
+            const info = await socks_1.SocksClient.createConnection({
+                proxy: {
+                    host: this.proxy.ip,
+                    port: this.proxy.port,
+                    type: this.proxy.socksType,
+                    userId: this.proxy.username,
+                    password: this.proxy.password,
+                },
+                command: "connect",
+                timeout: (this.proxy.timeout || 5) * 1000,
+                destination: {
+                    host: ip,
+                    port: port,
+                },
+            });
+            this.client = info.socket;
+            connected = true;
+        }
+        else {
+            this.client = new net.Socket();
+        }
+        this.canRead = new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+        this.closed = false;
+        return new Promise((resolve, reject) => {
+            if (this.client) {
+                if (connected) {
+                    this.receive();
+                    resolve(this);
+                }
+                else {
+                    this.client.connect(port, ip, () => {
+                        this.receive();
+                        resolve(this);
+                    });
+                }
+                this.client.on("error", reject);
+                this.client.on("close", () => {
+                    if (this.client && this.client.destroyed) {
+                        if (this.resolveRead) {
+                            this.resolveRead(false);
+                        }
+                        this.closed = true;
+                    }
+                });
+            }
+        });
+    }
+    write(data) {
+        if (this.closed) {
+            throw closeError;
+        }
+        if (this.client) {
+            this.client.write(data);
+        }
+    }
+    async close() {
+        if (this.client) {
+            await this.client.destroy();
+            this.client.unref();
+        }
+        this.closed = true;
+    }
+    async receive() {
+        if (this.client) {
+            this.client.on("data", async (message) => {
+                const release = await mutex.acquire();
+                try {
+                    let data;
+                    //CONTEST BROWSER
+                    this.stream = Buffer.concat([this.stream, message]);
+                    if (this.resolveRead) {
+                        this.resolveRead(true);
+                    }
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+    }
+    toString() {
+        return "PromisedNetSocket";
+    }
+}
+exports.PromisedNetSockets = PromisedNetSockets;

package/extensions/PromisedWebSockets.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+export declare class PromisedWebSockets {
+    private closed;
+    private stream;
+    private canRead?;
+    private resolveRead;
+    private client;
+    private website?;
+    constructor();
+    readExactly(number: number): Promise<Buffer>;
+    read(number: number): Promise<Buffer>;
+    readAll(): Promise<Buffer>;
+    getWebSocketLink(ip: string, port: number, testServers: boolean): string;
+    connect(port: number, ip: string, testServers?: boolean): Promise<unknown>;
+    write(data: Buffer): void;
+    close(): Promise<void>;
+    receive(): Promise<void>;
+    toString(): string;
+}

package/extensions/PromisedWebSockets.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisedWebSockets = void 0;
+const websocket_1 = require("websocket");
+const async_mutex_1 = require("async-mutex");
+const mutex = new async_mutex_1.Mutex();
+const closeError = new Error("WebSocket was closed");
+class PromisedWebSockets {
+    constructor() {
+        this.client = undefined;
+        this.stream = Buffer.alloc(0);
+        this.closed = true;
+    }
+    async readExactly(number) {
+        let readData = Buffer.alloc(0);
+        while (true) {
+            const thisTime = await this.read(number);
+            readData = Buffer.concat([readData, thisTime]);
+            number = number - thisTime.length;
+            if (!number) {
+                return readData;
+            }
+        }
+    }
+    async read(number) {
+        if (this.closed) {
+            throw closeError;
+        }
+        await this.canRead;
+        if (this.closed) {
+            throw closeError;
+        }
+        const toReturn = this.stream.slice(0, number);
+        this.stream = this.stream.slice(number);
+        if (this.stream.length === 0) {
+            this.canRead = new Promise((resolve) => {
+                this.resolveRead = resolve;
+            });
+        }
+        return toReturn;
+    }
+    async readAll() {
+        if (this.closed || !(await this.canRead)) {
+            throw closeError;
+        }
+        const toReturn = this.stream;
+        this.stream = Buffer.alloc(0);
+        this.canRead = new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+        return toReturn;
+    }
+    getWebSocketLink(ip, port, testServers) {
+        if (port === 443) {
+            return `wss://${ip}:${port}/apiws${testServers ? "_test" : ""}`;
+        }
+        else {
+            return `ws://${ip}:${port}/apiws${testServers ? "_test" : ""}`;
+        }
+    }
+    async connect(port, ip, testServers = false) {
+        this.stream = Buffer.alloc(0);
+        this.canRead = new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+        this.closed = false;
+        this.website = this.getWebSocketLink(ip, port, testServers);
+        this.client = new websocket_1.w3cwebsocket(this.website, "binary");
+        return new Promise((resolve, reject) => {
+            if (this.client) {
+                this.client.onopen = () => {
+                    this.receive();
+                    resolve(this);
+                };
+                this.client.onerror = (error) => {
+                    reject(error);
+                };
+                this.client.onclose = () => {
+                    if (this.resolveRead) {
+                        this.resolveRead(false);
+                    }
+                    this.closed = true;
+                };
+            }
+        });
+    }
+    write(data) {
+        if (this.closed) {
+            throw closeError;
+        }
+        if (this.client) {
+            this.client.send(data);
+        }
+    }
+    async close() {
+        if (this.client) {
+            await this.client.close();
+        }
+        this.closed = true;
+    }
+    async receive() {
+        if (this.client) {
+            this.client.onmessage = async (message) => {
+                const release = await mutex.acquire();
+                try {
+                    let data;
+                    //CONTEST BROWSER
+                    data = Buffer.from(await new Response(message.data).arrayBuffer());
+                    this.stream = Buffer.concat([this.stream, data]);
+                    if (this.resolveRead) {
+                        this.resolveRead(true);
+                    }
+                }
+                finally {
+                    release();
+                }
+            };
+        }
+    }
+    toString() {
+        return "PromisedWebSocket";
+    }
+}
+exports.PromisedWebSockets = PromisedWebSockets;

package/extensions/html.d.ts

@@ -0,0 +1,5 @@
+import { Api } from "../tl";
+export declare class HTMLParser {
+    static parse(html: string): [string, Api.TypeMessageEntity[]];
+    static unparse(text: string, entities: Api.TypeMessageEntity[] | undefined, _offset?: number, _length?: number): string;
+}

package/extensions/html.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTMLParser = void 0;
+const htmlparser2_1 = require("htmlparser2");
+const tl_1 = require("../tl");
+const index_1 = require("../index");
+class HTMLToTelegramParser {
+    constructor() {
+        this.text = "";
+        this.entities = [];
+        this._buildingEntities = new Map();
+        this._openTags = [];
+        this._openTagsMeta = [];
+    }
+    onopentag(name, attributes) {
+        /*
+         * This fires when a new tag is opened.
+         *
+         * If you don't need an aggregated `attributes` object,
+         * have a look at the `onopentagname` and `onattribute` events.
+         */
+        this._openTags.unshift(name);
+        this._openTagsMeta.unshift(undefined);
+        let EntityType;
+        const args = {};
+        if (name == "strong" || name == "b") {
+            EntityType = tl_1.Api.MessageEntityBold;
+        }
+        else if (name == "spoiler") {
+            EntityType = tl_1.Api.MessageEntitySpoiler;
+        }
+        else if (name == "em" || name == "i") {
+            EntityType = tl_1.Api.MessageEntityItalic;
+        }
+        else if (name == "u") {
+            EntityType = tl_1.Api.MessageEntityUnderline;
+        }
+        else if (name == "del" || name == "s") {
+            EntityType = tl_1.Api.MessageEntityStrike;
+        }
+        else if (name == "blockquote") {
+            EntityType = tl_1.Api.MessageEntityBlockquote;
+            if (attributes.expandable !== undefined) {
+                args.collapsed = true;
+            }
+        }
+        else if (name == "code") {
+            const pre = this._buildingEntities.get("pre");
+            if (pre && pre instanceof tl_1.Api.MessageEntityPre) {
+                try {
+                    pre.language = attributes.class.slice("language-".length, attributes.class.length);
+                }
+                catch (e) {
+                    // no language block
+                }
+            }
+            else {
+                EntityType = tl_1.Api.MessageEntityCode;
+            }
+        }
+        else if (name == "pre") {
+            EntityType = tl_1.Api.MessageEntityPre;
+            args["language"] = "";
+        }
+        else if (name == "a") {
+            let url = attributes.href;
+            if (!url) {
+                return;
+            }
+            if (url.startsWith("mailto:")) {
+                url = url.slice("mailto:".length, url.length);
+                EntityType = tl_1.Api.MessageEntityEmail;
+            }
+            else {
+                EntityType = tl_1.Api.MessageEntityTextUrl;
+                args["url"] = url;
+                url = undefined;
+            }
+            this._openTagsMeta.shift();
+            this._openTagsMeta.unshift(url);
+        }
+        else if (name == "tg-emoji") {
+            EntityType = tl_1.Api.MessageEntityCustomEmoji;
+            args["documentId"] = attributes["emoji-id"];
+        }
+        if (EntityType && !this._buildingEntities.has(name)) {
+            this._buildingEntities.set(name, new EntityType(Object.assign({ offset: this.text.length, length: 0 }, args)));
+        }
+    }
+    ontext(text) {
+        const previousTag = this._openTags.length > 0 ? this._openTags[0] : "";
+        if (previousTag == "a") {
+            const url = this._openTagsMeta[0];
+            if (url) {
+                text = url;
+            }
+        }
+        for (let [tag, entity] of this._buildingEntities) {
+            entity.length += text.length;
+        }
+        this.text += text;
+    }
+    onclosetag(tagname) {
+        this._openTagsMeta.shift();
+        this._openTags.shift();
+        const entity = this._buildingEntities.get(tagname);
+        if (entity) {
+            this._buildingEntities.delete(tagname);
+            this.entities.push(entity);
+        }
+    }
+    onattribute(name, value, quote) { }
+    oncdataend() { }
+    oncdatastart() { }
+    oncomment(data) { }
+    oncommentend() { }
+    onend() { }
+    onerror(error) { }
+    onopentagname(name) { }
+    onparserinit(parser) { }
+    onprocessinginstruction(name, data) { }
+    onreset() { }
+}
+class HTMLParser {
+    static parse(html) {
+        if (!html) {
+            return [html, []];
+        }
+        const handler = new HTMLToTelegramParser();
+        const parser = new htmlparser2_1.Parser(handler);
+        parser.write(html);
+        parser.end();
+        const text = index_1.helpers.stripText(handler.text, handler.entities);
+        return [text, handler.entities];
+    }
+    static unparse(text, entities, _offset = 0, _length) {
+        if (!text || !entities || !entities.length) {
+            return text;
+        }
+        if (_length == undefined) {
+            _length = text.length;
+        }
+        const html = [];
+        let lastOffset = 0;
+        for (let i = 0; i < entities.length; i++) {
+            const entity = entities[i];
+            if (entity.offset >= _offset + _length) {
+                break;
+            }
+            let relativeOffset = entity.offset - _offset;
+            if (relativeOffset > lastOffset) {
+                html.push(text.slice(lastOffset, relativeOffset));
+            }
+            else if (relativeOffset < lastOffset) {
+                continue;
+            }
+            let skipEntity = false;
+            let length = entity.length;
+            let entityText = this.unparse(text.slice(relativeOffset, relativeOffset + length), entities.slice(i + 1, entities.length), entity.offset, length);
+            if (entity instanceof tl_1.Api.MessageEntityBold) {
+                html.push(`<strong>${entityText}</strong>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntitySpoiler) {
+                html.push(`<spoiler>${entityText}</spoiler>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityItalic) {
+                html.push(`<em>${entityText}</em>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityCode) {
+                html.push(`<code>${entityText}</code>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityUnderline) {
+                html.push(`<u>${entityText}</u>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityStrike) {
+                html.push(`<del>${entityText}</del>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityBlockquote) {
+                html.push(`<blockquote>${entityText}</blockquote>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityPre) {
+                if (entity.language) {
+                    html.push(`<pre><code class="language-${entity.language}">${entityText}</code></pre>`);
+                }
+                else {
+                    html.push(`<pre>${entityText}</pre>`);
+                }
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityEmail) {
+                html.push(`<a href="mailto:${entityText}">${entityText}</a>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityUrl) {
+                html.push(`<a href="${entityText}">${entityText}</a>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityTextUrl) {
+                html.push(`<a href="${entity.url}">${entityText}</a>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityMentionName) {
+                html.push(`<a href="tg://user?id=${entity.userId}">${entityText}</a>`);
+            }
+            else if (entity instanceof tl_1.Api.MessageEntityCustomEmoji) {
+                html.push(`<tg-emoji emoji-id="${entity.documentId}">${entityText}</tg-emoji>`);
+            }
+            else {
+                skipEntity = true;
+            }
+            lastOffset = relativeOffset + (skipEntity ? 0 : length);
+        }
+        html.push(text.slice(lastOffset, text.length));
+        return html.join("");
+    }
+}
+exports.HTMLParser = HTMLParser;

package/extensions/index.d.ts

@@ -0,0 +1,7 @@
+export { Logger } from "./Logger";
+export { BinaryWriter } from "./BinaryWriter";
+export { BinaryReader } from "./BinaryReader";
+export { PromisedWebSockets } from "./PromisedWebSockets";
+export { PromisedNetSockets } from "./PromisedNetSockets";
+export { MessagePacker } from "./MessagePacker";
+export { AsyncQueue } from "./AsyncQueue";

package/extensions/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = exports.MessagePacker = exports.PromisedNetSockets = exports.PromisedWebSockets = exports.BinaryReader = exports.BinaryWriter = exports.Logger = void 0;
+var Logger_1 = require("./Logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return Logger_1.Logger; } });
+var BinaryWriter_1 = require("./BinaryWriter");
+Object.defineProperty(exports, "BinaryWriter", { enumerable: true, get: function () { return BinaryWriter_1.BinaryWriter; } });
+var BinaryReader_1 = require("./BinaryReader");
+Object.defineProperty(exports, "BinaryReader", { enumerable: true, get: function () { return BinaryReader_1.BinaryReader; } });
+var PromisedWebSockets_1 = require("./PromisedWebSockets");
+Object.defineProperty(exports, "PromisedWebSockets", { enumerable: true, get: function () { return PromisedWebSockets_1.PromisedWebSockets; } });
+var PromisedNetSockets_1 = require("./PromisedNetSockets");
+Object.defineProperty(exports, "PromisedNetSockets", { enumerable: true, get: function () { return PromisedNetSockets_1.PromisedNetSockets; } });
+var MessagePacker_1 = require("./MessagePacker");
+Object.defineProperty(exports, "MessagePacker", { enumerable: true, get: function () { return MessagePacker_1.MessagePacker; } });
+var AsyncQueue_1 = require("./AsyncQueue");
+Object.defineProperty(exports, "AsyncQueue", { enumerable: true, get: function () { return AsyncQueue_1.AsyncQueue; } });

package/extensions/markdown.d.ts

@@ -0,0 +1,5 @@
+import { Api } from "../tl";
+export declare class MarkdownParser {
+    static parse(message: string): [string, Api.TypeMessageEntity[]];
+    static unparse(text: string, entities: Api.TypeMessageEntity[] | undefined): string;
+}

package/extensions/markdown.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownParser = void 0;
+const messageParse_1 = require("../client/messageParse");
+class MarkdownParser {
+    // TODO maybe there is a better way :shrug:
+    static parse(message) {
+        let i = 0;
+        const keys = {};
+        for (const k in messageParse_1.DEFAULT_DELIMITERS) {
+            keys[k] = false;
+        }
+        const entities = [];
+        const tempEntities = {};
+        while (i < message.length) {
+            let foundIndex = -1;
+            let foundDelim = undefined;
+            for (const key of Object.keys(messageParse_1.DEFAULT_DELIMITERS)) {
+                const index = message.indexOf(key, i);
+                if (index > -1 && (foundIndex === -1 || index < foundIndex)) {
+                    foundIndex = index;
+                    foundDelim = key;
+                }
+            }
+            if (foundIndex === -1 || foundDelim == undefined) {
+                break;
+            }
+            if (!keys[foundDelim]) {
+                tempEntities[foundDelim] = new messageParse_1.DEFAULT_DELIMITERS[foundDelim]({
+                    offset: foundIndex,
+                    length: -1,
+                    language: "",
+                });
+                keys[foundDelim] = true;
+            }
+            else {
+                keys[foundDelim] = false;
+                tempEntities[foundDelim].length =
+                    foundIndex - tempEntities[foundDelim].offset;
+                entities.push(tempEntities[foundDelim]);
+            }
+            message = message.toString().replace(foundDelim, "");
+            i = foundIndex;
+        }
+        return [message, entities];
+    }
+    static unparse(text, entities) {
+        const delimiters = messageParse_1.DEFAULT_DELIMITERS;
+        if (!text || !entities) {
+            return text;
+        }
+        let insertAt = [];
+        const tempDelimiters = new Map();
+        Object.keys(delimiters).forEach((key) => {
+            tempDelimiters.set(delimiters[key].className, key);
+        });
+        for (const entity of entities) {
+            const s = entity.offset;
+            const e = entity.offset + entity.length;
+            const delimiter = tempDelimiters.get(entity.className);
+            if (delimiter) {
+                insertAt.push([s, delimiter]);
+                insertAt.push([e, delimiter]);
+            }
+        }
+        insertAt = insertAt.sort((a, b) => {
+            return a[0] - b[0];
+        });
+        while (insertAt.length) {
+            const [at, what] = insertAt.pop();
+            text = text.slice(0, at) + what + text.slice(at);
+        }
+        return text;
+    }
+}
+exports.MarkdownParser = MarkdownParser;

package/extensions/markdownv2.d.ts

@@ -0,0 +1,5 @@
+import { Api } from "../tl";
+export declare class MarkdownV2Parser {
+    static parse(message: string): [string, Api.TypeMessageEntity[]];
+    static unparse(text: string, entities: Api.TypeMessageEntity[] | undefined): string;
+}