@mtkruto/node 0.1.170 → 0.1.190

package/script/client/1_client_encrypted.d.ts

@@ -0,0 +1,34 @@
+import { enums, functions, ReadObject, TLObject, types } from "../2_tl.js";
+import { ClientAbstract } from "./0_client_abstract.js";
+import { ClientAbstractParams } from "./0_client_abstract.js";
+export type ErrorSource = "deserialization" | "decryption" | "unknown";
+export interface Handlers {
+    serverSaltReassigned?: (newServerSalt: bigint) => void;
+    updates?: (updates: enums.Updates | enums.Update, call: TLObject | null, callback?: () => void) => void;
+    result?: (result: ReadObject, callback: () => void) => void;
+    error?: (err: unknown, source: ErrorSource) => void;
+}
+/**
+ * An MTProto client for making encrypted connections. Most users won't need to interact with this. Used internally by `Client`.
+ *
+ * There are a few things to note:
+ *
+ * - This is a bare client and it stores nothing.
+ * - It expects an authorization key to be present before invoking any method.
+ * - Authorization must be set using `setAuthKey`.
+ * - Incoming packets that aren't a reply to a specific call are passed to the assigned handlers.
+ * - It doesn't uncompress compressed packets.
+ */
+export declare class ClientEncrypted extends ClientAbstract {
+    #private;
+    handlers: Handlers;
+    constructor(params?: ClientAbstractParams);
+    connect(): Promise<void>;
+    setAuthKey(key: Uint8Array): Promise<void>;
+    get authKey(): Uint8Array;
+    set serverSalt(serverSalt: bigint);
+    get serverSalt(): bigint;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait?: boolean): Promise<T | void>;
+}

package/script/client/1_client_encrypted.js

@@ -0,0 +1,243 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ClientEncrypted_instances, _ClientEncrypted_authKey, _ClientEncrypted_authKeyId, _ClientEncrypted_sessionId, _ClientEncrypted_state, _ClientEncrypted_toAcknowledge, _ClientEncrypted_recentAcks, _ClientEncrypted_promises, _ClientEncrypted_L, _ClientEncrypted_LreceiveLoop, _ClientEncrypted_Linvoke, _ClientEncrypted_nextMessageId, _ClientEncrypted_nextSeqNo, _ClientEncrypted_sendMessage, _ClientEncrypted_receiveLoop;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientEncrypted = void 0;
+const _0_deps_js_1 = require("../0_deps.js");
+const _1_utilities_js_1 = require("../1_utilities.js");
+const _2_tl_js_1 = require("../2_tl.js");
+const _4_errors_js_1 = require("../4_errors.js");
+const _0_client_abstract_js_1 = require("./0_client_abstract.js");
+const _0_message_js_1 = require("./0_message.js");
+const _0_types_js_1 = require("./0_types.js");
+// global ClientEncrypted ID counter for logs
+let id = 0;
+/**
+ * An MTProto client for making encrypted connections. Most users won't need to interact with this. Used internally by `Client`.
+ *
+ * There are a few things to note:
+ *
+ * - This is a bare client and it stores nothing.
+ * - It expects an authorization key to be present before invoking any method.
+ * - Authorization must be set using `setAuthKey`.
+ * - Incoming packets that aren't a reply to a specific call are passed to the assigned handlers.
+ * - It doesn't uncompress compressed packets.
+ */
+class ClientEncrypted extends _0_client_abstract_js_1.ClientAbstract {
+    constructor(params) {
+        super(params);
+        _ClientEncrypted_instances.add(this);
+        _ClientEncrypted_authKey.set(this, new Uint8Array());
+        _ClientEncrypted_authKeyId.set(this, 0n);
+        _ClientEncrypted_sessionId.set(this, (0, _1_utilities_js_1.getRandomBigInt)(8, true, false));
+        _ClientEncrypted_state.set(this, { serverSalt: 0n, seqNo: 0, messageId: 0n });
+        _ClientEncrypted_toAcknowledge.set(this, new Set());
+        _ClientEncrypted_recentAcks.set(this, new _1_utilities_js_1.CacheMap(20));
+        _ClientEncrypted_promises.set(this, new Map());
+        // loggers
+        _ClientEncrypted_L.set(this, void 0);
+        _ClientEncrypted_LreceiveLoop.set(this, void 0);
+        _ClientEncrypted_Linvoke.set(this, void 0);
+        // receive loop handlers
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        const L = __classPrivateFieldSet(this, _ClientEncrypted_L, (0, _1_utilities_js_1.getLogger)("ClientEncrypted").client(id++), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_LreceiveLoop, L.branch("receiveLoop"), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_Linvoke, L.branch("invoke"), "f");
+    }
+    async connect() {
+        await super.connect();
+        (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_receiveLoop).call(this)); // TODO: ability to join this promise
+    }
+    async setAuthKey(key) {
+        const hash = await (0, _1_utilities_js_1.sha1)(key);
+        __classPrivateFieldSet(this, _ClientEncrypted_authKeyId, (0, _1_utilities_js_1.bigIntFromBuffer)(hash.slice(-8), true, false), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_authKey, key, "f");
+    }
+    get authKey() {
+        return __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f");
+    }
+    set serverSalt(serverSalt) {
+        __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt = serverSalt;
+    }
+    get serverSalt() {
+        return __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt;
+    }
+    async invoke(function_, noWait) {
+        const messageId = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this);
+        const message__ = new _2_tl_js_1.Message_(messageId, __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, true), function_);
+        let message_;
+        let container = undefined;
+        if (__classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f").size) {
+            const ack = new _2_tl_js_1.Message_(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this), __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, false), new _2_tl_js_1.types.Msgs_ack({ msg_ids: [...__classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f")] }));
+            __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").set(ack.id, { container, message: ack });
+            message_ = new _2_tl_js_1.MessageContainer(container = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this), __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, false), [message__, ack]);
+        }
+        else {
+            message_ = message__;
+        }
+        await __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, message_);
+        __classPrivateFieldGet(this, _ClientEncrypted_Linvoke, "f").debug("invoked", function_[_2_tl_js_1.name]);
+        if (noWait) {
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").set(messageId, {
+                container,
+                message: message__,
+                call: function_,
+            });
+            return;
+        }
+        return await new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").set(messageId, { container, message: message__, resolve, reject, call: function_ });
+        }).then((v) => v);
+    }
+}
+exports.ClientEncrypted = ClientEncrypted;
+_ClientEncrypted_authKey = new WeakMap(), _ClientEncrypted_authKeyId = new WeakMap(), _ClientEncrypted_sessionId = new WeakMap(), _ClientEncrypted_state = new WeakMap(), _ClientEncrypted_toAcknowledge = new WeakMap(), _ClientEncrypted_recentAcks = new WeakMap(), _ClientEncrypted_promises = new WeakMap(), _ClientEncrypted_L = new WeakMap(), _ClientEncrypted_LreceiveLoop = new WeakMap(), _ClientEncrypted_Linvoke = new WeakMap(), _ClientEncrypted_instances = new WeakSet(), _ClientEncrypted_nextMessageId = function _ClientEncrypted_nextMessageId() {
+    return __classPrivateFieldGet(this, _ClientEncrypted_state, "f").messageId = (0, _0_message_js_1.getMessageId)(__classPrivateFieldGet(this, _ClientEncrypted_state, "f").messageId);
+}, _ClientEncrypted_nextSeqNo = function _ClientEncrypted_nextSeqNo(contentRelated) {
+    let seqNo = __classPrivateFieldGet(this, _ClientEncrypted_state, "f").seqNo * 2;
+    if (contentRelated) {
+        seqNo++;
+        __classPrivateFieldGet(this, _ClientEncrypted_state, "f").seqNo++;
+    }
+    return seqNo;
+}, _ClientEncrypted_sendMessage = async function _ClientEncrypted_sendMessage(message) {
+    const payload = await (0, _0_message_js_1.encryptMessage)(message, __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f"), __classPrivateFieldGet(this, _ClientEncrypted_authKeyId, "f"), __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt, __classPrivateFieldGet(this, _ClientEncrypted_sessionId, "f"));
+    await this.transport.transport.send(payload);
+    __classPrivateFieldGet(this, _ClientEncrypted_L, "f").out(message);
+    __classPrivateFieldGet(this, _ClientEncrypted_L, "f").outBin(payload);
+}, _ClientEncrypted_receiveLoop = async function _ClientEncrypted_receiveLoop() {
+    if (!this.transport) {
+        (0, _1_utilities_js_1.UNREACHABLE)();
+    }
+    while (this.connected) {
+        try {
+            const buffer = await this.transport.transport.receive();
+            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").inBin(buffer);
+            let decrypted;
+            try {
+                decrypted = await ((0, _0_message_js_1.decryptMessage)(buffer, __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f"), __classPrivateFieldGet(this, _ClientEncrypted_authKeyId, "f"), __classPrivateFieldGet(this, _ClientEncrypted_sessionId, "f")));
+                __classPrivateFieldGet(this, _ClientEncrypted_L, "f").in(decrypted);
+            }
+            catch (err) {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("failed to decrypt message:", err);
+                this.handlers.error?.(err, "decryption");
+                continue;
+            }
+            const messages = decrypted instanceof _2_tl_js_1.MessageContainer ? decrypted.messages : [decrypted];
+            for (const message of messages) {
+                let body = message.body;
+                if (body instanceof _2_tl_js_1.types.Gzip_packed) {
+                    body = new _2_tl_js_1.TLReader((0, _0_deps_js_1.gunzip)(body.packed_data)).readObject();
+                }
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("received", (typeof body === "object" && _2_tl_js_1.name in body) ? body[_2_tl_js_1.name] : body.constructor.name);
+                if (body instanceof _2_tl_js_1.types._Updates || body instanceof _2_tl_js_1.types._Update) {
+                    this.handlers.updates?.(body, null);
+                }
+                else if (body instanceof _2_tl_js_1.types.New_session_created) {
+                    this.serverSalt = body.server_salt;
+                    this.handlers.serverSaltReassigned?.(this.serverSalt);
+                }
+                else if (message.body instanceof _2_tl_js_1.RPCResult) {
+                    let result = message.body.result;
+                    if (result instanceof _2_tl_js_1.types.Gzip_packed) {
+                        result = new _2_tl_js_1.TLReader((0, _0_deps_js_1.gunzip)(result.packed_data)).readObject();
+                    }
+                    if (result instanceof _2_tl_js_1.types.Rpc_error) {
+                        __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("RPCResult:", result.error_code, result.error_message);
+                    }
+                    else {
+                        __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("RPCResult:", (typeof result === "object" && _2_tl_js_1.name in result) ? result[_2_tl_js_1.name] : result.constructor.name);
+                    }
+                    const messageId = message.body.messageId;
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(messageId);
+                    const resolvePromise = () => {
+                        if (promise) {
+                            if (result instanceof _2_tl_js_1.types.Rpc_error) {
+                                promise.reject?.((0, _4_errors_js_1.upgradeInstance)(result, promise.call));
+                            }
+                            else {
+                                promise.resolve?.(result);
+                            }
+                            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(messageId);
+                        }
+                    };
+                    if (result instanceof _2_tl_js_1.types._Updates || result instanceof _2_tl_js_1.types._Update) {
+                        this.handlers.updates?.(result, promise?.call ?? null, resolvePromise);
+                    }
+                    else {
+                        this.handlers.result?.(result, resolvePromise);
+                    }
+                }
+                else if (message.body instanceof _2_tl_js_1.types.Pong) {
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(message.body.msg_id);
+                    if (promise) {
+                        promise.resolve?.(message.body);
+                        __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(message.body.msg_id);
+                    }
+                }
+                else if (message.body instanceof _2_tl_js_1.types.Bad_server_salt) {
+                    __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("server salt reassigned");
+                    this.serverSalt = message.body.new_server_salt;
+                    this.handlers.serverSaltReassigned?.(this.serverSalt);
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(message.body.bad_msg_id);
+                    const ack = __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").get(message.body.bad_msg_id);
+                    if (promise) {
+                        (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, promise.message));
+                    }
+                    else if (ack) {
+                        (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, ack.message));
+                    }
+                    else {
+                        for (const promise of __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").values()) {
+                            if (promise.container && promise.container == message.body.bad_msg_id) {
+                                (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, promise.message));
+                            }
+                        }
+                        for (const ack of __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").values()) {
+                            if (ack.container && ack.container == message.body.bad_msg_id) {
+                                (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, ack.message));
+                            }
+                        }
+                    }
+                }
+                __classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f").add(message.id);
+            }
+        }
+        catch (err) {
+            if (!this.connected) {
+                break;
+            }
+            else if (err instanceof _2_tl_js_1.TLError) {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("failed to deserialize:", err);
+                this.handlers.error?.(err, "deserialization");
+            }
+            else {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("unexpected error:", err);
+            }
+        }
+    }
+    if (!this.connected) {
+        for (const [key, { reject }] of __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").entries()) {
+            reject?.(new _0_types_js_1.ConnectionError("Connection was closed"));
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(key);
+        }
+    }
+    else {
+        (0, _1_utilities_js_1.UNREACHABLE)();
+    }
+};

package/script/client/{2_client_plain.d.ts → 1_client_plain.d.ts}

@@ -7,6 +7,9 @@ export interface ClientPlainParams extends ClientAbstractParams {
      */
     publicKeys?: PublicKeys;
 }
+/**
+ * An MTProto client for making plain connections. Most users won't need to interact with this. Used internally for creating authorization keys.
+ */
 export declare class ClientPlain extends ClientAbstract {
     #private;
     constructor(params?: ClientPlainParams);

package/script/client/{2_client_plain.js → 1_client_plain.js}

@@ -21,11 +21,14 @@ const _0_client_abstract_js_1 = require("./0_client_abstract.js");
 const _0_message_js_1 = require("./0_message.js");
 const L = (0, _1_utilities_js_1.getLogger)("ClientPlain");
 const LcreateAuthKey = L.branch("createAuthKey");
+/**
+ * An MTProto client for making plain connections. Most users won't need to interact with this. Used internally for creating authorization keys.
+ */
 class ClientPlain extends _0_client_abstract_js_1.ClientAbstract {
     constructor(params) {
         super(params);
         _ClientPlain_publicKeys.set(this, void 0);
-        _ClientPlain_lastMsgId.set(this, 0n);
+        _ClientPlain_lastMsgId.set(this, 0n); // TODO: refactor
         __classPrivateFieldSet(this, _ClientPlain_publicKeys, params?.publicKeys ?? _4_constants_js_1.PUBLIC_KEYS, "f");
     }
     async invoke(function_) {

package/script/client/1_composer.d.ts

@@ -1,7 +1,7 @@
+import { MaybePromise } from "../1_utilities.js";
 import { Update, UpdateIntersection, User } from "../3_types.js";
 import { FilterQuery, WithFilter } from "./0_filters.js";
-type MaybePromise<T> = T | Promise<T>;
-export type NextFunction = () => Promise<void>;
+export type NextFunction<T = void> = () => Promise<T>;
 export type MiddlewareFn<C> = (ctx: C, next: NextFunction) => MaybePromise<unknown>;
 export interface MiddlewareObj<C> {
     middleware: () => MiddlewareFn<C>;
@@ -27,4 +27,3 @@ export declare class Composer<C extends {
         prefixes: string | string[];
     }, ...middleware: Middleware<WithFilter<C, "message:text">>[]): Composer<WithFilter<C, "message:text">>;
 }
-export {};

package/script/client/2_message_manager.d.ts

@@ -1,6 +1,6 @@
 import { enums, types } from "../2_tl.js";
 import { ChatAction, ChatMember, FileSource, FileType, ID, Message, MessageEntity, ParseMode, Reaction, Update, UsernameResolver } from "../3_types.js";
-import { AddReactionParams, BanChatMemberParams, CreateInviteLinkParams, DeleteMessagesParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetCreatedInviteLinksParams, GetHistoryParams, PinMessageParams, SearchMessagesParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams, SetChatMemberRightsParams, SetChatPhotoParams, SetReactionsParams } from "./0_params.js";
+import { AddReactionParams, BanChatMemberParams, CreateInviteLinkParams, DeleteMessagesParams, EditMessageLiveLocationParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetCreatedInviteLinksParams, GetHistoryParams, PinMessageParams, SearchMessagesParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendStickerParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams, SetChatMemberRightsParams, SetChatPhotoParams, SetReactionsParams, StopPollParams } from "./0_params.js";
 import { C as C_ } from "./0_types.js";
 import { FileManager } from "./1_file_manager.js";
 interface C extends C_ {
@@ -13,7 +13,8 @@ export declare class MessageManager {
     getMessages(chatId: ID, messageIds: number[]): Promise<Message[]>;
     getMessageWithReply(chatId: ID, messageId: number): Promise<Message>;
     getMessage(chatId: ID, messageId: number): Promise<Message>;
-    parseText(text: string, params?: {
+    static parseText(text: string, entities: MessageEntity[], parseMode: ParseMode): [string, MessageEntity[]];
+    parseText(text_: string, params?: {
         parseMode?: ParseMode;
         entities?: MessageEntity[];
     }): Promise<readonly [string, enums.MessageEntity[] | undefined]>;
@@ -32,8 +33,9 @@ export declare class MessageManager {
     sendAnimation(chatId: ID, animation: FileSource, params?: SendAnimationParams): Promise<import("../3_types.js").MessageAnimation>;
     sendVideo(chatId: ID, video: FileSource, params?: SendVideoParams): Promise<import("../3_types.js").MessageVideo>;
     sendDocument(chatId: ID, document: FileSource, params?: SendDocumentParams): Promise<import("../3_types.js").MessageDocument>;
+    sendSticker(chatId: ID, sticker: FileSource, params?: SendStickerParams): Promise<import("../3_types.js").MessageSticker>;
     sendPhoto(chatId: ID, photo: FileSource, params?: SendPhotoParams): Promise<import("../3_types.js").MessagePhoto>;
-    resolveFileId(maybeFileId: string, expectedFileType: FileType): {
+    resolveFileId(maybeFileId: string, expectedFileType: FileType | FileType[]): {
         id: bigint;
         access_hash: bigint;
         file_reference: Uint8Array;
@@ -76,5 +78,8 @@ export declare class MessageManager {
     getChatMember(chatId: ID, userId: ID): Promise<ChatMember>;
     setChatStickerSet(chatId: ID, setName: string): Promise<void>;
     deleteChatStickerSet(chatId: ID): Promise<void>;
+    stopPoll(chatId: ID, messageId: number, params?: StopPollParams): Promise<import("../3_types.js").Poll>;
+    editMessageLiveLocation(chatId: ID, messageId: number, latitude: number, longitude: number, params?: EditMessageLiveLocationParams): Promise<import("../3_types.js").MessageLocation>;
+    editInlineMessageLiveLocation(inlineMessageId: string, latitude: number, longitude: number, params?: EditMessageLiveLocationParams): Promise<void>;
 }
 export {};

package/script/client/2_message_manager.js

@@ -20,7 +20,10 @@ const _3_types_js_1 = require("../3_types.js");
 const _3_types_js_2 = require("../3_types.js");
 const _0_message_search_filter_js_1 = require("../types/0_message_search_filter.js");
 const _0_html_js_1 = require("./0_html.js");
+const _0_markdown_js_1 = require("./0_markdown.js");
 const _0_utilities_js_1 = require("./0_utilities.js");
+const FALLBACK_MIME_TYPE = "application/octet-stream";
+const STICKER_MIME_TYPES = ["image/webp", "video/webp", "application/x-tgsticker"];
 class MessageManager {
     constructor(c) {
         _MessageManager_instances.add(this);
@@ -89,9 +92,7 @@ class MessageManager {
         const messages = await this.getMessages(chatId, [messageId]);
         return messages[0] ?? null;
     }
-    async parseText(text, params) {
-        const entities_ = params?.entities ?? [];
-        const parseMode = params?.parseMode ?? __classPrivateFieldGet(this, _MessageManager_c, "f").parseMode;
+    static parseText(text, entities, parseMode) {
         switch (parseMode) {
             case null:
                 break;
@@ -99,13 +100,31 @@ class MessageManager {
                 const [newText, entitiesToPush] = (0, _0_html_js_1.parseHtml)(text);
                 text = newText;
                 for (const entity of entitiesToPush) {
-                    entities_.push(entity);
+                    entities.push(entity);
+                }
+                break;
+            }
+            case "Markdown": {
+                const [newText, entitiesToPush] = (0, _0_markdown_js_1.parseMarkdown)(text);
+                text = newText;
+                for (const entity of entitiesToPush) {
+                    entities.push(entity);
                 }
                 break;
             }
             default:
                 (0, _1_utilities_js_1.UNREACHABLE)();
         }
+        text = text.trimEnd();
+        for (const entity of entities) {
+            while (text[entity.offset + (entity.length - 1)] === undefined) {
+                --entity.length;
+            }
+        }
+        return [text, entities];
+    }
+    async parseText(text_, params) {
+        const [text, entities_] = MessageManager.parseText(text_, params?.entities ?? [], params?.parseMode ?? __classPrivateFieldGet(this, _MessageManager_c, "f").parseMode);
         const entities = entities_?.length > 0 ? await Promise.all(entities_.map((v) => (0, _3_types_js_2.messageEntityToTlObject)(v, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity))) : undefined;
         return [text, entities];
     }
@@ -388,11 +407,15 @@ class MessageManager {
         const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, document, params, _3_types_js_2.FileType.Document, []);
         return (0, _3_types_js_2.assertMessageType)(message, "document");
     }
+    async sendSticker(chatId, sticker, params) {
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, sticker, params, _3_types_js_2.FileType.Sticker, [new _2_tl_js_1.types.DocumentAttributeSticker({ alt: params?.emoji || "", stickerset: new _2_tl_js_1.types.InputStickerSetEmpty() })], undefined, STICKER_MIME_TYPES);
+        return (0, _3_types_js_2.assertMessageType)(message, "sticker");
+    }
     async sendPhoto(chatId, photo, params) {
         let media = null;
         const spoiler = params?.hasSpoiler ? true : undefined;
         if (typeof photo === "string") {
-            const fileId = this.resolveFileId(photo, _3_types_js_2.FileType.Photo);
+            const fileId = this.resolveFileId(photo, [_3_types_js_2.FileType.Photo, _3_types_js_2.FileType.ProfilePhoto]);
             if (fileId != null) {
                 media = new _2_tl_js_1.types.InputMediaPhoto({
                     id: new _2_tl_js_1.types.InputPhoto(fileId),
@@ -414,6 +437,7 @@ class MessageManager {
         return (0, _3_types_js_2.assertMessageType)(message, "photo");
     }
     resolveFileId(maybeFileId, expectedFileType) {
+        expectedFileType = Array.isArray(expectedFileType) ? expectedFileType : [expectedFileType];
         let fileId = null;
         try {
             fileId = (0, _3_types_js_1.deserializeFileId)(maybeFileId);
@@ -422,7 +446,7 @@ class MessageManager {
             __classPrivateFieldGet(this, _MessageManager_LresolveFileId, "f").warning(err);
         }
         if (fileId != null) {
-            if (fileId.type != expectedFileType) {
+            if (!expectedFileType.includes(fileId.type)) {
                 (0, _1_utilities_js_1.UNREACHABLE)();
             }
             return {
@@ -985,6 +1009,66 @@ class MessageManager {
         const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputChannel(chatId);
         await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.setStickers({ channel, stickerset: new _2_tl_js_1.types.InputStickerSetEmpty() });
     }
+    async stopPoll(chatId, messageId, params) {
+        const message = await this.getMessage(chatId, messageId);
+        if (message && "poll" in message && !message.poll.isClosed) {
+            const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editMessage({
+                peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+                id: messageId,
+                media: new _2_tl_js_1.types.InputMediaPoll({
+                    poll: new _2_tl_js_1.types.Poll({
+                        id: BigInt(message.poll.id),
+                        closed: true,
+                        question: "",
+                        answers: [],
+                    }),
+                }),
+                reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
+            });
+            const message_ = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+            return (0, _3_types_js_2.assertMessageType)(message_, "poll").poll;
+        }
+        (0, _1_utilities_js_1.UNREACHABLE)();
+    }
+    async editMessageLiveLocation(chatId, messageId, latitude, longitude, params) {
+        const message = await this.getMessage(chatId, messageId);
+        if (message && "location" in message && message.location.livePeriod) {
+            const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editMessage({
+                peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+                id: messageId,
+                media: new _2_tl_js_1.types.InputMediaGeoLive({
+                    geo_point: new _2_tl_js_1.types.InputGeoPoint({
+                        lat: latitude,
+                        long: longitude,
+                        accuracy_radius: params?.horizontalAccuracy,
+                    }),
+                    heading: params?.heading,
+                    proximity_notification_radius: params?.proximityAlertRadius,
+                }),
+                reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
+            });
+            const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+            return (0, _3_types_js_2.assertMessageType)(message, "location");
+        }
+        (0, _1_utilities_js_1.UNREACHABLE)();
+    }
+    async editInlineMessageLiveLocation(inlineMessageId, latitude, longitude, params) {
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("editInlineMessageLiveLocation");
+        const id = (0, _3_types_js_2.deserializeInlineMessageId)(inlineMessageId);
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editInlineBotMessage({
+            id,
+            media: new _2_tl_js_1.types.InputMediaGeoLive({
+                geo_point: new _2_tl_js_1.types.InputGeoPoint({
+                    lat: latitude,
+                    long: longitude,
+                    accuracy_radius: params?.horizontalAccuracy,
+                }),
+                heading: params?.heading,
+                proximity_notification_radius: params?.proximityAlertRadius,
+            }),
+            reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
+        });
+    }
 }
 exports.MessageManager = MessageManager;
 _MessageManager_c = new WeakMap(), _MessageManager_LresolveFileId = new WeakMap(), _MessageManager_instances = new WeakSet(), _MessageManager_updatesToMessages = async function _MessageManager_updatesToMessages(chatId, updates) {
@@ -1024,7 +1108,7 @@ _MessageManager_c = new WeakMap(), _MessageManager_LresolveFileId = new WeakMap(
     const topMsgId = params?.messageThreadId;
     const replyToMsgId = params?.replyToMessageId;
     return replyToMsgId !== undefined ? new _2_tl_js_1.types.InputReplyToMessage({ reply_to_msg_id: replyToMsgId, top_msg_id: topMsgId, quote_text: params?.replyQuote?.text, quote_entities: await Promise.all(params?.replyQuote?.entities.map((v) => (0, _3_types_js_2.messageEntityToTlObject)(v, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity)) ?? []), quote_offset: params?.replyQuote?.offset }) : undefined;
-}, _MessageManager_sendDocumentInner = async function _MessageManager_sendDocumentInner(chatId, document, params, fileType, otherAttribs, urlSupported = false) {
+}, _MessageManager_sendDocumentInner = async function _MessageManager_sendDocumentInner(chatId, document, params, fileType, otherAttribs, urlSupported = false, expectedMimeTypes) {
     let media = null;
     const spoiler = params?.hasSpoiler ? true : undefined;
     if (typeof document === "string") {
@@ -1033,6 +1117,7 @@ _MessageManager_c = new WeakMap(), _MessageManager_LresolveFileId = new WeakMap(
             media = new _2_tl_js_1.types.InputMediaDocument({
                 id: new _2_tl_js_1.types.InputDocument(fileId),
                 spoiler,
+                query: otherAttribs.find((v) => v instanceof _2_tl_js_1.types.DocumentAttributeSticker)?.alt || undefined,
             });
         }
     }
@@ -1045,8 +1130,14 @@ _MessageManager_c = new WeakMap(), _MessageManager_LresolveFileId = new WeakMap(
         }
         else {
             const [contents, fileName_] = await (0, _0_utilities_js_1.getFileContents)(document);
-            const fileName = params?.fileName ?? fileName_;
-            const mimeType = params?.mimeType ?? (0, _0_deps_js_1.contentType)(fileName.split(".").slice(-1)[0]) ?? "application/octet-stream";
+            let fileName = params?.fileName ?? fileName_;
+            const mimeType = params?.mimeType ?? (0, _0_deps_js_1.contentType)(fileName.split(".").slice(-1)[0]) ?? FALLBACK_MIME_TYPE;
+            if (expectedMimeTypes && !expectedMimeTypes.includes(mimeType)) {
+                (0, _1_utilities_js_1.UNREACHABLE)();
+            }
+            if (fileName.endsWith(".tgs") && fileType == _3_types_js_2.FileType.Document) {
+                fileName += "-";
+            }
             const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(contents, { fileName, chunkSize: params?.chunkSize, signal: params?.signal });
             let thumb = undefined;
             if (params?.thumbnail) {
@@ -1059,6 +1150,7 @@ _MessageManager_c = new WeakMap(), _MessageManager_LresolveFileId = new WeakMap(
                 spoiler,
                 attributes: [new _2_tl_js_1.types.DocumentAttributeFilename({ file_name: fileName }), ...otherAttribs],
                 mime_type: mimeType,
+                force_file: fileType == _3_types_js_2.FileType.Document ? true : undefined,
             });
         }
     }