teleproto 1.214.0

package/extensions/PromisedNetSockets.d.ts

@@ -0,0 +1,24 @@
+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<ArrayBuffer>>;
+    read(number: number): Promise<Buffer<ArrayBuffer>>;
+    readAll(): Promise<Buffer<ArrayBufferLike>>;
+    /**
+     * 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,192 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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,18 @@
+export declare class PromisedWebSockets {
+    private closed;
+    private stream;
+    private canRead?;
+    private resolveRead;
+    private client;
+    private website?;
+    constructor();
+    readExactly(number: number): Promise<Buffer<ArrayBuffer>>;
+    read(number: number): Promise<Buffer<ArrayBuffer>>;
+    readAll(): Promise<Buffer<ArrayBufferLike>>;
+    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,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTMLParser = void 0;
+const tl_1 = require("../tl");
+const index_1 = require("../index");
+class HTMLParser {
+    static parse(html) {
+        if (!html) {
+            return [html, []];
+        }
+        const text = [];
+        const entities = [];
+        const openTags = [];
+        const buildingEntities = new Map();
+        let pos = 0;
+        let textPos = 0;
+        while (pos < html.length) {
+            const tagStart = html.indexOf('<', pos);
+            if (tagStart === -1) {
+                const textContent = html.substring(pos);
+                text.push(textContent);
+                for (const [_, entity] of buildingEntities) {
+                    entity.length += textContent.length;
+                }
+                break;
+            }
+            if (tagStart > pos) {
+                const textContent = html.substring(pos, tagStart);
+                text.push(textContent);
+                for (const [_, entity] of buildingEntities) {
+                    entity.length += textContent.length;
+                }
+                textPos += textContent.length;
+            }
+            const tagEnd = html.indexOf('>', tagStart);
+            if (tagEnd === -1) {
+                text.push(html.substring(tagStart));
+                break;
+            }
+            const tagContent = html.substring(tagStart + 1, tagEnd);
+            if (tagContent.startsWith('/')) {
+                const tagName = tagContent.substring(1).trim().toLowerCase();
+                const entity = buildingEntities.get(tagName);
+                if (entity) {
+                    buildingEntities.delete(tagName);
+                    entities.push(entity);
+                }
+                const index = openTags.findIndex(t => t.name === tagName);
+                if (index !== -1) {
+                    openTags.splice(index, 1);
+                }
+            }
+            else {
+                let tagName = tagContent;
+                let attributes = {};
+                const spaceIndex = tagContent.indexOf(' ');
+                if (spaceIndex !== -1) {
+                    tagName = tagContent.substring(0, spaceIndex).toLowerCase();
+                    const attrStr = tagContent.substring(spaceIndex + 1);
+                    const attrRegex = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]*)))?/g;
+                    let match;
+                    while ((match = attrRegex.exec(attrStr)) !== null) {
+                        const name = match[1];
+                        const value = match[2] || match[3] || match[4] || '';
+                        attributes[name] = value;
+                    }
+                }
+                else {
+                    tagName = tagContent.toLowerCase();
+                }
+                if (tagName.endsWith('/')) {
+                    tagName = tagName.slice(0, -1);
+                    pos = tagEnd + 1;
+                    continue;
+                }
+                let tagMeta = undefined;
+                openTags.unshift({ name: tagName, meta: tagMeta });
+                let EntityType;
+                const args = {};
+                if (tagName === "strong" || tagName === "b") {
+                    EntityType = tl_1.Api.MessageEntityBold;
+                }
+                else if (tagName === "spoiler") {
+                    EntityType = tl_1.Api.MessageEntitySpoiler;
+                }
+                else if (tagName === "em" || tagName === "i") {
+                    EntityType = tl_1.Api.MessageEntityItalic;
+                }
+                else if (tagName === "u") {
+                    EntityType = tl_1.Api.MessageEntityUnderline;
+                }
+                else if (tagName === "del" || tagName === "s") {
+                    EntityType = tl_1.Api.MessageEntityStrike;
+                }
+                else if (tagName === "blockquote") {
+                    EntityType = tl_1.Api.MessageEntityBlockquote;
+                    if (attributes.expandable !== undefined) {
+                        args.collapsed = true;
+                    }
+                }
+                else if (tagName === "code") {
+                    const pre = buildingEntities.get("pre");
+                    if (pre && pre instanceof tl_1.Api.MessageEntityPre) {
+                        if (attributes.class && attributes.class.startsWith('language-')) {
+                            pre.language = attributes.class.slice("language-".length);
+                        }
+                    }
+                    else {
+                        EntityType = tl_1.Api.MessageEntityCode;
+                    }
+                }
+                else if (tagName === "pre") {
+                    EntityType = tl_1.Api.MessageEntityPre;
+                    args["language"] = "";
+                }
+                else if (tagName === "a") {
+                    let url = attributes.href;
+                    if (url) {
+                        if (url.startsWith("mailto:")) {
+                            url = url.slice("mailto:".length);
+                            EntityType = tl_1.Api.MessageEntityEmail;
+                            tagMeta = url;
+                        }
+                        else {
+                            EntityType = tl_1.Api.MessageEntityTextUrl;
+                            args["url"] = url;
+                        }
+                        openTags[0].meta = tagMeta;
+                    }
+                }
+                else if (tagName === "tg-emoji") {
+                    EntityType = tl_1.Api.MessageEntityCustomEmoji;
+                    args["documentId"] = attributes["emoji-id"];
+                }
+                if (EntityType && !buildingEntities.has(tagName)) {
+                    buildingEntities.set(tagName, new EntityType(Object.assign({ offset: textPos, length: 0 }, args)));
+                }
+                if (tagName === "a" && tagMeta) {
+                    text.push(tagMeta);
+                    for (const [_, entity] of buildingEntities) {
+                        entity.length += tagMeta.length;
+                    }
+                    textPos += tagMeta.length;
+                }
+            }
+            pos = tagEnd + 1;
+        }
+        const finalText = text.join('');
+        return [index_1.helpers.stripText(finalText, entities), 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;
+}