@mtkruto/node 0.0.830 → 0.0.831

package/script/client/client.js

@@ -23,12 +23,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = exports.restartAuth = void 0;
+exports.Client = exports.ParseMode = exports.restartAuth = void 0;
 const deps_js_1 = require("../deps.js");
 const constants_js_1 = require("../constants.js");
 const _0_bigint_js_1 = require("../utilities/0_bigint.js");
+const _0_html_js_1 = require("../utilities/0_html.js");
 const _1_message_js_1 = require("../utilities/1_message.js");
 const _1_password_js_1 = require("../utilities/1_password.js");
+const _1_tl_object_js_1 = require("../tl/1_tl_object.js");
 const types = __importStar(require("../tl/2_types.js"));
 const functions = __importStar(require("../tl/3_functions.js"));
 const _3_tl_reader_js_1 = require("../tl/3_tl_reader.js");
@@ -39,7 +41,13 @@ const client_abstract_js_1 = require("./client_abstract.js");
 const client_plain_js_1 = require("./client_plain.js");
 const storage_memory_js_1 = require("../storage/storage_memory.js");
 const _0_hash_js_1 = require("../utilities/0_hash.js");
+const _0_message_entity_js_1 = require("../types/0_message_entity.js");
 exports.restartAuth = Symbol();
+var ParseMode;
+(function (ParseMode) {
+    ParseMode["None"] = "none";
+    ParseMode["HTML"] = "html";
+})(ParseMode = exports.ParseMode || (exports.ParseMode = {}));
 class Client extends client_abstract_js_1.ClientAbstract {
     /**
      * Constructs the client.
@@ -105,6 +113,12 @@ class Client extends client_abstract_js_1.ClientAbstract {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "parseMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "appVersion", {
             enumerable: true,
             configurable: true,
@@ -147,6 +161,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
             writable: true,
             value: false
         });
+        this.parseMode = params?.parseMode ?? ParseMode.None;
         this.appVersion = params?.appVersion ?? constants_js_1.DEFAULT_APP_VERSION;
         this.deviceModel = params?.deviceModel ?? constants_js_1.DEFAULT_DEVICE_MODEL;
         this.langCode = params?.langCode ?? constants_js_1.DEFAULT_LANG_CODE;
@@ -417,7 +432,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
                 }
                 // logger().debug(`Received ${body.constructor.name}`);
                 if (body instanceof types.Updates) {
-                    this.updatesHandler?.(this, body);
+                    this.processUpdates(body);
                 }
                 else if (message.body instanceof _4_rpc_result_js_1.RPCResult) {
                     let result = message.body.result;
@@ -430,6 +445,10 @@ class Client extends client_abstract_js_1.ClientAbstract {
                             promise.reject(result);
                         }
                         else {
+                            if (result instanceof types.Updates) {
+                                await this.processChats(result.chats);
+                                await this.processUsers(result.users);
+                            }
                             promise.resolve(result);
                         }
                         this.promises.delete(message.body.messageId);
@@ -498,5 +517,149 @@ class Client extends client_abstract_js_1.ClientAbstract {
     send(function_) {
         return this.invoke(function_, true);
     }
+    async processChats(chats) {
+        for (const chat of chats) {
+            if (chat instanceof types.Channel && chat.accessHash) {
+                await this.storage.setChannelAccessHash(chat.id, chat.accessHash);
+                if (chat.username) {
+                    await this.storage.updateUsernames("channel", chat.id, [chat.username]);
+                }
+                if (chat.usernames) {
+                    await this.storage.updateUsernames("channel", chat.id, chat.usernames.map((v) => v[_1_tl_object_js_1.as](types.Username)).map((v) => v.username));
+                }
+            }
+        }
+    }
+    async processUsers(users) {
+        for (const user of users) {
+            if (user instanceof types.User && user.accessHash) {
+                await this.storage.setUserAccessHash(user.id, user.accessHash);
+                if (user.username) {
+                    await this.storage.updateUsernames("user", user.id, [user.username]);
+                }
+                if (user.usernames) {
+                    await this.storage.updateUsernames("user", user.id, user.usernames.map((v) => v[_1_tl_object_js_1.as](types.Username)).map((v) => v.username));
+                }
+            }
+        }
+    }
+    async processUpdates(updates) {
+        try {
+            await this.processChats(updates.chats);
+            await this.processUsers(updates.users);
+            for (const update of updates.updates) {
+                if (update instanceof types.UpdateUserName) {
+                    await this.storage.updateUsernames("user", update.userId, update.usernames.map((v) => v[_1_tl_object_js_1.as](types.Username)).map((v) => v.username));
+                }
+            }
+            await this.updatesHandler?.(this, updates);
+        }
+        catch (err) {
+            console.error("Error processing updates:", err);
+        }
+    }
+    async getInputPeer(id) {
+        if (typeof id === "string") {
+            if (!id.startsWith("@")) {
+                throw new Error("Expected username to start with @");
+            }
+            else {
+                id = id.slice(1);
+                if (!id) {
+                    throw new Error("Empty username");
+                }
+                let userId = 0n;
+                let channelId = 0n;
+                const maybeUsername = await this.storage.getUsername(id);
+                if (maybeUsername != null && Date.now() - maybeUsername[2].getTime() < constants_js_1.USERNAME_TTL) {
+                    const [type, id] = maybeUsername;
+                    if (type == "user") {
+                        userId = id;
+                    }
+                    else {
+                        channelId = id;
+                    }
+                }
+                else {
+                    const resolved = await this.invoke(new functions.ContactsResolveUsername({ username: id }));
+                    await this.processChats(resolved.chats);
+                    await this.processUsers(resolved.users);
+                    if (resolved.peer instanceof types.PeerUser) {
+                        userId = resolved.peer.userId;
+                    }
+                    else if (resolved.peer instanceof types.PeerChannel) {
+                        channelId = resolved.peer.channelId;
+                    }
+                    else {
+                        throw new Error("Unreachable");
+                    }
+                }
+                if (userId) {
+                    const accessHash = await this.storage.getUserAccessHash(userId);
+                    return new types.InputPeerUser({ userId, accessHash: accessHash ?? 0n });
+                }
+                else if (channelId) {
+                    const accessHash = await this.storage.getChannelAccessHash(channelId);
+                    return new types.InputPeerChannel({ channelId, accessHash: accessHash ?? 0n });
+                }
+                else {
+                    throw new Error("Unreachable");
+                }
+            }
+        }
+        else if (id > 0) {
+            const id_ = BigInt(id);
+            const accessHash = await this.storage.getUserAccessHash(id_);
+            return new types.InputPeerUser({ userId: id_, accessHash: accessHash ?? 0n });
+        }
+        else if (-constants_js_1.MAX_CHAT_ID <= id) {
+            return new types.InputPeerChat({ chatId: BigInt(Math.abs(id)) });
+        }
+        else if (constants_js_1.ZERO_CHANNEL_ID - constants_js_1.MAX_CHANNEL_ID <= id && id != constants_js_1.ZERO_CHANNEL_ID) {
+            const id_ = BigInt(Math.abs(id - constants_js_1.ZERO_CHANNEL_ID));
+            const accessHash = await this.storage.getChannelAccessHash(id_);
+            return new types.InputPeerChannel({ channelId: id_, accessHash: accessHash ?? 0n });
+        }
+        else {
+            throw new Error("ID format unknown or not implemented");
+        }
+    }
+    async sendMessage(chatId, text, params) {
+        const entities_ = params?.entities ?? [];
+        const parseMode = params?.parseMode ?? this.parseMode;
+        switch (parseMode) {
+            case ParseMode.None:
+                break;
+            case ParseMode.HTML: {
+                const [newText, entitiesToPush] = (0, _0_html_js_1.parseHtml)(text);
+                text = newText;
+                for (const entity of entitiesToPush) {
+                    entities_.push(entity);
+                }
+            }
+        }
+        const peer = await this.getInputPeer(chatId);
+        const randomId = (0, _0_bigint_js_1.getRandomId)();
+        const message = text;
+        const noWebpage = params?.disableWebPagePreview ? true : undefined;
+        const silent = params?.disableNotification ? true : undefined;
+        const noforwards = params?.protectContent ? true : undefined;
+        const replyToMsgId = params?.replyToMessageId;
+        const topMsgId = params?.messageThreadId;
+        const sendAs = params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined;
+        const entities = entities_?.length > 0 ? entities_.map((v) => (0, _0_message_entity_js_1.messageEntityToTlObject)(v)) : undefined;
+        return await this.invoke(new functions.MessagesSendMessage({
+            peer,
+            randomId,
+            message,
+            noWebpage,
+            silent,
+            noforwards,
+            replyToMsgId,
+            topMsgId,
+            sendAs,
+            entities,
+        }));
+    }
 }
 exports.Client = Client;

package/script/constants.d.ts

@@ -10,3 +10,7 @@ export declare const DEFAULT_LANG_CODE = "en";
 export declare const DEFAULT_LANG_PACK = "";
 export declare const DEFAULT_SYSTEM_LANG_CODE = "en";
 export declare const DEFAULT_SYSTEM_VERSION = "1.0";
+export declare const USERNAME_TTL = 86400;
+export declare const MAX_CHAT_ID = 999999999999;
+export declare const MAX_CHANNEL_ID = 997852516352;
+export declare const ZERO_CHANNEL_ID = -1000000000000;

package/script/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SYSTEM_VERSION = exports.DEFAULT_SYSTEM_LANG_CODE = exports.DEFAULT_LANG_PACK = exports.DEFAULT_LANG_CODE = exports.DEFAULT_DEVICE_MODEL = exports.DEFAULT_APP_VERSION = exports.LAYER = exports.DEFAULT_INITIAL_DC = exports.VECTOR_CONSTRUCTOR = exports.publicKeys = exports.ackThreshold = void 0;
+exports.ZERO_CHANNEL_ID = exports.MAX_CHANNEL_ID = exports.MAX_CHAT_ID = exports.USERNAME_TTL = exports.DEFAULT_SYSTEM_VERSION = exports.DEFAULT_SYSTEM_LANG_CODE = exports.DEFAULT_LANG_PACK = exports.DEFAULT_LANG_CODE = exports.DEFAULT_DEVICE_MODEL = exports.DEFAULT_APP_VERSION = exports.LAYER = exports.DEFAULT_INITIAL_DC = exports.VECTOR_CONSTRUCTOR = exports.publicKeys = exports.ackThreshold = void 0;
 exports.ackThreshold = 10;
 exports.publicKeys = new Map([
     [
@@ -71,3 +71,7 @@ exports.DEFAULT_LANG_CODE = "en";
 exports.DEFAULT_LANG_PACK = "";
 exports.DEFAULT_SYSTEM_LANG_CODE = "en";
 exports.DEFAULT_SYSTEM_VERSION = "1.0";
+exports.USERNAME_TTL = 86400;
+exports.MAX_CHAT_ID = 999999999999;
+exports.MAX_CHANNEL_ID = 997852516352;
+exports.ZERO_CHANNEL_ID = -1000000000000;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.d.ts

@@ -0,0 +1,83 @@
+import { Node, Element, Document, NodeWithChildren, DataNode } from './Node.js';
+export interface DomHandlerOptions {
+    /**
+     * Add a `startIndex` property to nodes.
+     * When the parser is used in a non-streaming fashion, `startIndex` is an integer
+     * indicating the position of the start of the node in the document.
+     *
+     * @default false
+     */
+    withStartIndices?: boolean;
+    /**
+     * Add an `endIndex` property to nodes.
+     * When the parser is used in a non-streaming fashion, `endIndex` is an integer
+     * indicating the position of the end of the node in the document.
+     *
+     * @default false
+     */
+    withEndIndices?: boolean;
+    /**
+     * Replace all whitespace with single spaces.
+     *
+     * **Note:** Enabling this might break your markup.
+     *
+     * @default false
+     * @deprecated
+     */
+    normalizeWhitespace?: boolean;
+    /**
+     * Treat the markup as XML.
+     *
+     * @default false
+     */
+    xmlMode?: boolean;
+}
+interface ParserInterface {
+    startIndex: number | null;
+    endIndex: number | null;
+}
+type Callback = (error: Error | null, dom: Node[]) => void;
+type ElementCallback = (element: Element) => void;
+export declare class DomHandler {
+    /** The elements of the DOM */
+    dom: Node[];
+    /** The root element for the DOM */
+    root: Document;
+    /** Called once parsing has completed. */
+    private readonly callback;
+    /** Settings for the handler. */
+    private readonly options;
+    /** Callback whenever a tag is closed. */
+    private readonly elementCB;
+    /** Indicated whether parsing has been completed. */
+    private done;
+    /** Stack of open tags. */
+    protected tagStack: NodeWithChildren[];
+    /** A data node that is still being written to. */
+    protected lastNode: DataNode | null;
+    /** Reference to the parser instance. Used for location information. */
+    private parser;
+    /**
+     * @param callback Called once parsing has completed.
+     * @param options Settings for the handler.
+     * @param elementCB Callback whenever a tag is closed.
+     */
+    constructor(callback?: Callback | null, options?: DomHandlerOptions | null, elementCB?: ElementCallback);
+    onparserinit(parser: ParserInterface): void;
+    onreset(): void;
+    onend(): void;
+    onerror(error: Error): void;
+    onclosetag(): void;
+    onopentag(name: string, attribs: {
+        [key: string]: string;
+    }): void;
+    ontext(data: string): void;
+    oncomment(data: string): void;
+    oncommentend(): void;
+    oncdatastart(): void;
+    oncdataend(): void;
+    onprocessinginstruction(name: string, data: string): void;
+    protected handleCallback(error: Error | null): void;
+    protected addNode(node: Node): void;
+}
+export default DomHandler;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomHandler = void 0;
+const Node_js_1 = require("./Node.js");
+const ElementType_js_1 = require("./ElementType.js");
+const reWhitespace = /\s+/g;
+// Default options
+const defaultOpts = {
+    normalizeWhitespace: false,
+    withStartIndices: false,
+    withEndIndices: false,
+};
+class DomHandler {
+    /**
+     * @param callback Called once parsing has completed.
+     * @param options Settings for the handler.
+     * @param elementCB Callback whenever a tag is closed.
+     */
+    constructor(callback, options, elementCB) {
+        /** The elements of the DOM */
+        Object.defineProperty(this, "dom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        /** The root element for the DOM */
+        Object.defineProperty(this, "root", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Node_js_1.Document(this.dom)
+        });
+        /** Called once parsing has completed. */
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Settings for the handler. */
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Callback whenever a tag is closed. */
+        Object.defineProperty(this, "elementCB", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Indicated whether parsing has been completed. */
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** Stack of open tags. */
+        Object.defineProperty(this, "tagStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [this.root]
+        });
+        /** A data node that is still being written to. */
+        Object.defineProperty(this, "lastNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Reference to the parser instance. Used for location information. */
+        Object.defineProperty(this, "parser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Make it possible to skip arguments, for backwards-compatibility
+        if (typeof options === 'function') {
+            elementCB = options;
+            options = defaultOpts;
+        }
+        if (typeof callback === 'object') {
+            options = callback;
+            callback = undefined;
+        }
+        this.callback = callback ?? null;
+        this.options = options ?? defaultOpts;
+        this.elementCB = elementCB ?? null;
+    }
+    onparserinit(parser) {
+        this.parser = parser;
+    }
+    // Resets the handler back to starting state
+    onreset() {
+        this.dom = [];
+        this.root = new Node_js_1.Document(this.dom);
+        this.done = false;
+        this.tagStack = [this.root];
+        this.lastNode = null;
+        this.parser = this.parser ?? null;
+    }
+    // Signals the handler that parsing is done
+    onend() {
+        if (this.done)
+            return;
+        this.done = true;
+        this.parser = null;
+        this.handleCallback(null);
+    }
+    onerror(error) {
+        this.handleCallback(error);
+    }
+    onclosetag() {
+        this.lastNode = null;
+        const elem = this.tagStack.pop();
+        if (this.options.withEndIndices) {
+            elem.endIndex = this.parser.endIndex;
+        }
+        if (this.elementCB)
+            this.elementCB(elem);
+    }
+    onopentag(name, attribs) {
+        const type = this.options.xmlMode ? ElementType_js_1.ElementType.Tag : undefined;
+        const element = new Node_js_1.Element(name, attribs, undefined, type);
+        this.addNode(element);
+        this.tagStack.push(element);
+    }
+    ontext(data) {
+        const { normalizeWhitespace } = this.options;
+        const { lastNode } = this;
+        if (lastNode && lastNode.type === ElementType_js_1.ElementType.Text) {
+            if (normalizeWhitespace) {
+                lastNode.data = (lastNode.data + data).replace(reWhitespace, ' ');
+            }
+            else {
+                lastNode.data += data;
+            }
+        }
+        else {
+            if (normalizeWhitespace) {
+                data = data.replace(reWhitespace, ' ');
+            }
+            const node = new Node_js_1.Text(data);
+            this.addNode(node);
+            this.lastNode = node;
+        }
+    }
+    oncomment(data) {
+        if (this.lastNode && this.lastNode.type === ElementType_js_1.ElementType.Comment) {
+            this.lastNode.data += data;
+            return;
+        }
+        const node = new Node_js_1.Comment(data);
+        this.addNode(node);
+        this.lastNode = node;
+    }
+    oncommentend() {
+        this.lastNode = null;
+    }
+    oncdatastart() {
+        const text = new Node_js_1.Text('');
+        const node = new Node_js_1.NodeWithChildren(ElementType_js_1.ElementType.CDATA, [text]);
+        this.addNode(node);
+        text.parent = node;
+        this.lastNode = text;
+    }
+    oncdataend() {
+        this.lastNode = null;
+    }
+    onprocessinginstruction(name, data) {
+        const node = new Node_js_1.ProcessingInstruction(name, data);
+        this.addNode(node);
+    }
+    handleCallback(error) {
+        if (typeof this.callback === 'function') {
+            this.callback(error, this.dom);
+        }
+        else if (error) {
+            throw error;
+        }
+    }
+    addNode(node) {
+        const parent = this.tagStack[this.tagStack.length - 1];
+        const previousSibling = parent.children[parent.children.length - 1];
+        if (this.options.withStartIndices) {
+            node.startIndex = this.parser.startIndex;
+        }
+        if (this.options.withEndIndices) {
+            node.endIndex = this.parser.endIndex;
+        }
+        parent.children.push(node);
+        if (previousSibling) {
+            node.prev = previousSibling;
+            previousSibling.next = node;
+        }
+        node.parent = parent;
+        this.lastNode = null;
+    }
+}
+exports.DomHandler = DomHandler;
+exports.default = DomHandler;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.d.ts

@@ -0,0 +1,50 @@
+import type { Node } from './Node.js';
+/**
+ * Mixed-case SVG and MathML tags & attributes
+ * recognized by the HTML parser.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
+ */
+export declare const elementNames: Map<string, string>;
+export declare const attributeNames: Map<string, string>;
+export interface DomSerializerOptions {
+    /**
+     * Print an empty attribute's value.
+     *
+     * @default xmlMode
+     * @example With <code>emptyAttrs: false</code>: <code>&lt;input checked&gt;</code>
+     * @example With <code>emptyAttrs: true</code>: <code>&lt;input checked=""&gt;</code>
+     */
+    emptyAttrs?: boolean;
+    /**
+     * Print self-closing tags for tags without contents.
+     *
+     * @default xmlMode
+     * @example With <code>selfClosingTags: false</code>: <code>&lt;foo&gt;&lt;/foo&gt;</code>
+     * @example With <code>selfClosingTags: true</code>: <code>&lt;foo /&gt;</code>
+     */
+    selfClosingTags?: boolean;
+    /**
+     * Treat the input as an XML document; enables the `emptyAttrs` and `selfClosingTags` options.
+     *
+     * If the value is `"foreign"`, it will try to correct mixed-case attribute names.
+     *
+     * @default false
+     */
+    xmlMode?: boolean | 'foreign';
+    /**
+     * Encode characters that are either reserved in HTML or XML, or are outside of the ASCII range.
+     *
+     * @default true
+     */
+    decodeEntities?: boolean;
+}
+/**
+ * Renders a DOM node or an array of DOM nodes to a string.
+ *
+ * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).
+ *
+ * @param node Node to be rendered.
+ * @param options Changes serialization behavior
+ */
+export default function render(node: Node | ArrayLike<Node>, options?: DomSerializerOptions): string;