@mtkruto/node 0.1.112 → 0.1.114

package/esm/client/{4_client.js → 5_client.js}

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _Client_instances, _a, _Client_auth, _Client_sessionId, _Client_state, _Client_promises, _Client_toAcknowledge, _Client_updateState, _Client_errorHandler, _Client_publicKeys, _Client_autoStart, _Client_propagateConnectionState, _Client_lastPropagatedConnectionState, _Client_storageInited, _Client_setAuth, _Client_authKeyWasCreated, _Client_connectMutex, _Client_assertUser, _Client_assertBot, _Client_fetchState, _Client_connectionInited, _Client_initConnection, _Client_lastPropagatedAuthorizationState, _Client_propagateAuthorizationState, _Client_selfId, _Client_getSelfId, _Client_receiveLoop, _Client_pingLoop, _Client_lastOutgoing, _Client_pingLoopStarted, _Client_autoStarted, _Client_lastMsgId, _Client_processChats, _Client_processUsers, _Client_handleUpdateQueue, _Client_processUpdatesQueue, _Client_checkChannelGap, _Client_processUpdates, _Client_setUpdateStateDate, _Client_getLocalState, _Client_recoverUpdateGap, _Client_recoverChannelUpdateGap, _Client_getChannelAccessHash, _Client_getInputPeerInner, _Client_updatesToMessages, _Client_resolveSendAs, _Client_parseText, _Client_getMessagesInner, _Client_downloadInner, _Client_handleUpdate, _Client_usernameResolver, _Client_constructReplyMarkup, _Client_assertMsgHas, _Client_handle, _Client_setMyInfo, _Client_getMyInfo;
+var _Client_instances, _a, _Client_auth, _Client_sessionId, _Client_state, _Client_promises, _Client_toAcknowledge, _Client_updateState, _Client_publicKeys, _Client_autoStart, _Client_constructContext, _Client_propagateConnectionState, _Client_lastPropagatedConnectionState, _Client_storageInited, _Client_setAuth, _Client_authKeyWasCreated, _Client_connectMutex, _Client_assertUser, _Client_assertBot, _Client_fetchState, _Client_connectionInited, _Client_initConnection, _Client_lastPropagatedAuthorizationState, _Client_propagateAuthorizationState, _Client_selfId, _Client_getSelfId, _Client_receiveLoop, _Client_pingInterval, _Client_pingLoop, _Client_pingLoopStarted, _Client_autoStarted, _Client_lastMsgId, _Client_invoke, _Client_handleInvokeError, _Client_processChats, _Client_processUsers, _Client_handleUpdateQueue, _Client_processUpdatesQueue, _Client_checkChannelGap, _Client_processUpdates, _Client_setUpdateStateDate, _Client_getLocalState, _Client_recoverUpdateGap, _Client_recoverChannelUpdateGap, _Client_getChannelAccessHash, _Client_getInputPeerInner, _Client_updatesToMessages, _Client_resolveSendAs, _Client_parseText, _Client_getMessagesInner, _Client_downloadInner, _Client_handleUpdate, _Client_usernameResolver, _Client_constructReplyMarkup, _Client_assertMsgHas, _Client_handle, _Client_setMyInfo, _Client_getMyInfo;
 import { debug, gunzip, Mutex } from "../0_deps.js";
 import { bigIntFromBuffer, drop, getRandomBigInt, getRandomId, mod, mustPrompt, mustPromptOneOf, Queue, sha1, UNREACHABLE } from "../1_utilities.js";
 import { as, functions, getChannelChatId, Message_, MessageContainer, peerToChatId, RPCResult, TLError, TLReader, types } from "../2_tl.js";
@@ -20,10 +20,10 @@ import { AuthKeyUnregistered, FloodWait, Migrate, PasswordHashInvalid, PhoneNumb
 import { parseHtml } from "./0_html.js";
 import { decryptMessage, encryptMessage, getMessageId } from "./0_message.js";
 import { checkPassword } from "./0_password.js";
-import { isChannelPtsUpdate, isPtsUpdate, resolve } from "./0_utilities.js";
+import { getFileContents, isChannelPtsUpdate, isHttpUrl, isPtsUpdate, resolve } from "./0_utilities.js";
 import { ClientAbstract } from "./1_client_abstract.js";
 import { ClientPlain } from "./2_client_plain.js";
-import { skip } from "./3_types.js";
+import { Composer, concat, flatten, skip } from "./4_composer.js";
 const d = debug("Client");
 const dGap = debug("Client/recoverUpdateGap");
 const dGapC = debug("Client/recoverChannelUpdateGap");
@@ -34,6 +34,9 @@ const getEntity = Symbol();
 const getStickerSetName = Symbol();
 export const handleMigrationError = Symbol();
 const getMessageWithReply = Symbol();
+export function skipInvoke() {
+    return (_ctx, next) => next();
+}
 export const restartAuth = Symbol();
 export class ConnectionError extends Error {
 }
@@ -66,7 +69,6 @@ export class Client extends ClientAbstract {
         _Client_promises.set(this, new Map());
         _Client_toAcknowledge.set(this, new Set());
         _Client_updateState.set(this, void 0);
-        _Client_errorHandler.set(this, void 0);
         Object.defineProperty(this, "storage", {
             enumerable: true,
             configurable: true,
@@ -117,17 +119,116 @@ export class Client extends ClientAbstract {
         });
         _Client_publicKeys.set(this, void 0);
         _Client_autoStart.set(this, void 0);
+        _Client_constructContext.set(this, (update) => {
+            const msg = update.message ?? update.editedMessage ?? update.callbackQuery?.message;
+            const mustGetMsg = () => {
+                if (msg !== undefined) {
+                    return msg;
+                }
+                else {
+                    UNREACHABLE();
+                }
+            };
+            const chat = msg?.chat;
+            const from = update.callbackQuery?.from ?? update.inlineQuery?.from ?? update.message?.from ?? update.editedMessage?.from;
+            const senderChat = msg?.senderChat;
+            const getReplyToMessageId = (quote, effectiveMessage) => {
+                const shouldQuote = quote === undefined ? effectiveMessage.chat.type != "private" : quote;
+                const replyToMessageId = shouldQuote ? effectiveMessage.id : undefined;
+                return replyToMessageId;
+            };
+            return {
+                ...update,
+                client: this,
+                msg,
+                chat,
+                from,
+                senderChat,
+                reply: (text, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    const replyToMessageId = getReplyToMessageId(params?.quote, effectiveMessage);
+                    return this.sendMessage(effectiveMessage.chat.id, text, { ...params, replyToMessageId });
+                },
+                replyPoll: (question, options, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    const replyToMessageId = getReplyToMessageId(params?.quote, effectiveMessage);
+                    return this.sendPoll(effectiveMessage.chat.id, question, options, { ...params, replyToMessageId });
+                },
+                replyPhoto: (photo, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    const replyToMessageId = getReplyToMessageId(params?.quote, effectiveMessage);
+                    return this.sendPhoto(effectiveMessage.chat.id, photo, { ...params, replyToMessageId });
+                },
+                delete: () => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.deleteMessage(effectiveMessage.chat.id, effectiveMessage.id);
+                },
+                forward: (to, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.forwardMessage(effectiveMessage.chat.id, to, effectiveMessage.id, params);
+                },
+                answerCallbackQuery: (params) => {
+                    const { callbackQuery } = update;
+                    if (callbackQuery === undefined) {
+                        UNREACHABLE();
+                    }
+                    return this.answerCallbackQuery(callbackQuery.id, params);
+                },
+                answerInlineQuery: (results, params) => {
+                    const { inlineQuery } = update;
+                    if (inlineQuery == undefined) {
+                        UNREACHABLE();
+                    }
+                    return this.answerInlineQuery(inlineQuery.id, results, params);
+                },
+                sendChatAction: (chatAction, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.sendChatAction(effectiveMessage.chat.id, chatAction, params);
+                },
+                editMessageText: (messageId, text, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.editMessageText(effectiveMessage.chat.id, messageId, text, params);
+                },
+                getMessage: (messageId) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.getMessage(effectiveMessage.chat.id, messageId);
+                },
+                getMessages: (messageIds) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.getMessages(effectiveMessage.chat.id, messageIds);
+                },
+                forwardMessage: (to, messageId, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.forwardMessage(effectiveMessage.chat.id, to, messageId, params);
+                },
+                forwardMessages: (to, messageIds, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.forwardMessages(effectiveMessage.chat.id, to, messageIds, params);
+                },
+                deleteMessage: (messageId, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.deleteMessage(effectiveMessage.chat.id, messageId, params);
+                },
+                deleteMessages: (messageIds, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.deleteMessages(effectiveMessage.chat.id, messageIds, params);
+                },
+                get toJSON() {
+                    return () => update;
+                },
+            };
+        });
         _Client_lastPropagatedConnectionState.set(this, null);
         Object.defineProperty(this, "stateChangeHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ((connected) => {
-                __classPrivateFieldGet(this, _Client_connectMutex, "f").acquire().then(async (release) => {
+                __classPrivateFieldGet(this, _Client_connectMutex, "f").acquire().then((release) => {
                     try {
                         const connectionState = connected ? "ready" : "notConnected";
                         if (this.connected == connected && __classPrivateFieldGet(this, _Client_lastPropagatedConnectionState, "f") != connectionState) {
-                            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateConnectionState).call(this, connectionState);
+                            __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateConnectionState).call(this, connectionState);
                             __classPrivateFieldSet(this, _Client_lastPropagatedConnectionState, connectionState, "f");
                         }
                     }
@@ -143,16 +244,43 @@ export class Client extends ClientAbstract {
         _Client_connectionInited.set(this, false);
         _Client_lastPropagatedAuthorizationState.set(this, null);
         _Client_selfId.set(this, null);
-        _Client_lastOutgoing.set(this, null);
+        _Client_pingInterval.set(this, 60 * 1000); // 60 seconds
         _Client_pingLoopStarted.set(this, false);
         _Client_autoStarted.set(this, false);
         _Client_lastMsgId.set(this, 0n);
+        _Client_handleInvokeError.set(this, skipInvoke());
+        /**
+         * Invokes a function waiting and returning its reply if the second parameter is not `true`. Requires the client
+         * to be connected.
+         *
+         * @param function_ The function to invoke.
+         */
+        Object.defineProperty(this, "invoke", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: Object.assign(__classPrivateFieldGet(this, _Client_instances, "m", _Client_invoke), {
+                use: (handler) => {
+                    const handle = __classPrivateFieldGet(this, _Client_handleInvokeError, "f");
+                    __classPrivateFieldSet(this, _Client_handleInvokeError, async (ctx, next) => {
+                        let result = null;
+                        return await handle(ctx, async () => {
+                            if (result != null)
+                                return result;
+                            result = await handler(ctx, next);
+                            return result;
+                        });
+                    }, "f");
+                },
+            })
+        });
         _Client_handleUpdateQueue.set(this, new Queue("handleUpdate"));
         _Client_processUpdatesQueue.set(this, new Queue("processUpdates"));
         _Client_usernameResolver.set(this, async (v) => {
             const inputPeer = await this.getInputPeer(v).then((v) => v[as](types.InputPeerUser));
             return new types.InputUser({ userId: inputPeer.userId, accessHash: inputPeer.accessHash });
         });
+        //#region Composer
         _Client_handle.set(this, skip);
         this.storage = storage ?? new StorageMemory();
         this.parseMode = params?.parseMode ?? null;
@@ -164,7 +292,41 @@ export class Client extends ClientAbstract {
         this.systemVersion = params?.systemVersion ?? SYSTEM_VERSION;
         __classPrivateFieldSet(this, _Client_publicKeys, params?.publicKeys, "f");
         __classPrivateFieldSet(this, _Client_autoStart, params?.autoStart ?? true, "f");
-        __classPrivateFieldSet(this, _Client_errorHandler, params?.errorHandler, "f");
+        if (params?.defaultHandlers ?? true) {
+            this.on("connectionState", ({ connectionState }, next) => {
+                drop((async () => {
+                    if (connectionState == "notConnected") {
+                        let delay = 5;
+                        while (!this.connected) {
+                            d("reconnecting");
+                            try {
+                                await this.connect();
+                                d("reconnected");
+                                break;
+                            }
+                            catch (err) {
+                                d("failed to reconnect, retrying in %d: %o", delay, err);
+                            }
+                            await new Promise((r) => setTimeout(r, delay * 1000));
+                            if (delay < 15) {
+                                delay += 5;
+                            }
+                        }
+                    }
+                })());
+                return next();
+            });
+            this.invoke.use(async ({ error }, next) => {
+                if (error instanceof FloodWait && error.seconds <= 10) {
+                    d("sleeping for %d because of: %o", error.seconds, error);
+                    await new Promise((r) => setTimeout(r, 1000 * error.seconds));
+                    return true;
+                }
+                else {
+                    return next();
+                }
+            });
+        }
     }
     /**
      * Sets the DC and resets the auth key stored in the session provider
@@ -231,14 +393,17 @@ export class Client extends ClientAbstract {
             }
             d("encrypted client connected");
             drop(__classPrivateFieldGet(this, _Client_instances, "m", _Client_receiveLoop).call(this));
+            if (__classPrivateFieldGet(this, _Client_pingLoopStarted, "f")) {
+                drop(__classPrivateFieldGet(this, _Client_instances, "m", _Client_pingLoop).call(this));
+            }
         }
         finally {
             release();
         }
     }
-    async [(_Client_auth = new WeakMap(), _Client_sessionId = new WeakMap(), _Client_state = new WeakMap(), _Client_promises = new WeakMap(), _Client_toAcknowledge = new WeakMap(), _Client_updateState = new WeakMap(), _Client_errorHandler = new WeakMap(), _Client_publicKeys = new WeakMap(), _Client_autoStart = new WeakMap(), _Client_lastPropagatedConnectionState = new WeakMap(), _Client_storageInited = new WeakMap(), _Client_authKeyWasCreated = new WeakMap(), _Client_connectMutex = new WeakMap(), _Client_connectionInited = new WeakMap(), _Client_lastPropagatedAuthorizationState = new WeakMap(), _Client_selfId = new WeakMap(), _Client_lastOutgoing = new WeakMap(), _Client_pingLoopStarted = new WeakMap(), _Client_autoStarted = new WeakMap(), _Client_lastMsgId = new WeakMap(), _Client_handleUpdateQueue = new WeakMap(), _Client_processUpdatesQueue = new WeakMap(), _Client_usernameResolver = new WeakMap(), _Client_handle = new WeakMap(), _Client_instances = new WeakSet(), _Client_propagateConnectionState = function _Client_propagateConnectionState(connectionState) {
+    async [(_Client_auth = new WeakMap(), _Client_sessionId = new WeakMap(), _Client_state = new WeakMap(), _Client_promises = new WeakMap(), _Client_toAcknowledge = new WeakMap(), _Client_updateState = new WeakMap(), _Client_publicKeys = new WeakMap(), _Client_autoStart = new WeakMap(), _Client_constructContext = new WeakMap(), _Client_lastPropagatedConnectionState = new WeakMap(), _Client_storageInited = new WeakMap(), _Client_authKeyWasCreated = new WeakMap(), _Client_connectMutex = new WeakMap(), _Client_connectionInited = new WeakMap(), _Client_lastPropagatedAuthorizationState = new WeakMap(), _Client_selfId = new WeakMap(), _Client_pingInterval = new WeakMap(), _Client_pingLoopStarted = new WeakMap(), _Client_autoStarted = new WeakMap(), _Client_lastMsgId = new WeakMap(), _Client_handleInvokeError = new WeakMap(), _Client_handleUpdateQueue = new WeakMap(), _Client_processUpdatesQueue = new WeakMap(), _Client_usernameResolver = new WeakMap(), _Client_handle = new WeakMap(), _Client_instances = new WeakSet(), _Client_propagateConnectionState = function _Client_propagateConnectionState(connectionState) {
         __classPrivateFieldGet(this, _Client_handleUpdateQueue, "f").add(async () => {
-            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { connectionState }, resolve);
+            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, __classPrivateFieldGet(this, _Client_constructContext, "f").call(this, { connectionState }), resolve);
         });
     }, _Client_setAuth = async function _Client_setAuth(key) {
         const hash = await sha1(key);
@@ -468,70 +633,6 @@ export class Client extends ClientAbstract {
         }
         await this.authorize(params);
     }
-    async invoke(function_, noWait) {
-        if (!__classPrivateFieldGet(this, _Client_auth, "f") || !this.transport) {
-            if (__classPrivateFieldGet(this, _Client_autoStart, "f") && !__classPrivateFieldGet(this, _Client_autoStarted, "f")) {
-                await this.start();
-            }
-            else {
-                throw new ConnectionError("Not connected");
-            }
-        }
-        if (!__classPrivateFieldGet(this, _Client_auth, "f") || !this.transport) {
-            UNREACHABLE();
-        }
-        let n = 1;
-        while (true) {
-            try {
-                let seqNo = __classPrivateFieldGet(this, _Client_state, "f").seqNo * 2;
-                if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
-                    seqNo++;
-                    __classPrivateFieldGet(this, _Client_state, "f").seqNo++;
-                }
-                const messageId = __classPrivateFieldSet(this, _Client_lastMsgId, getMessageId(__classPrivateFieldGet(this, _Client_lastMsgId, "f")), "f");
-                const message = new Message_(messageId, seqNo, function_);
-                await this.transport.transport.send(await encryptMessage(message, __classPrivateFieldGet(this, _Client_auth, "f").key, __classPrivateFieldGet(this, _Client_auth, "f").id, __classPrivateFieldGet(this, _Client_state, "f").salt, __classPrivateFieldGet(this, _Client_sessionId, "f")));
-                __classPrivateFieldSet(this, _Client_lastOutgoing, new Date(), "f");
-                d("invoked %s", function_.constructor.name);
-                if (noWait) {
-                    return;
-                }
-                let result;
-                try {
-                    result = await new Promise((resolve, reject) => {
-                        __classPrivateFieldGet(this, _Client_promises, "f").set(message.id, { resolve, reject });
-                    });
-                }
-                catch (err) {
-                    if (err instanceof AuthKeyUnregistered) {
-                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateAuthorizationState).call(this, false);
-                    }
-                    throw err;
-                }
-                if (result instanceof types.BadServerSalt) {
-                    return await this.invoke(function_);
-                }
-                else {
-                    if (!__classPrivateFieldGet(this, _Client_pingLoopStarted, "f")) {
-                        drop(__classPrivateFieldGet(this, _Client_instances, "m", _Client_pingLoop).call(this));
-                        __classPrivateFieldSet(this, _Client_pingLoopStarted, true, "f");
-                    }
-                    return result;
-                }
-            }
-            catch (err) {
-                if (__classPrivateFieldGet(this, _Client_errorHandler, "f") === undefined) {
-                    throw err;
-                }
-                if (__classPrivateFieldGet(this, _Client_errorHandler, "f") !== undefined && await __classPrivateFieldGet(this, _Client_errorHandler, "f").call(this, err, function_, n++)) {
-                    continue;
-                }
-                else {
-                    throw err;
-                }
-            }
-        }
-    }
     /**
      * Alias for `invoke` with its second parameter being `true`.
      */
@@ -586,7 +687,7 @@ export class Client extends ClientAbstract {
         }
     }, _Client_propagateAuthorizationState = async function _Client_propagateAuthorizationState(authorized) {
         if (__classPrivateFieldGet(this, _Client_lastPropagatedAuthorizationState, "f") != authorized) {
-            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { authorizationState: { authorized } }, resolve);
+            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, __classPrivateFieldGet(this, _Client_constructContext, "f").call(this, { authorizationState: { authorized } }), resolve);
             __classPrivateFieldSet(this, _Client_lastPropagatedAuthorizationState, authorized, "f");
         }
     }, _Client_getSelfId = async function _Client_getSelfId() {
@@ -706,17 +807,81 @@ export class Client extends ClientAbstract {
         }
     }, _Client_pingLoop = async function _Client_pingLoop() {
         while (this.connected) {
-            await new Promise((r) => setTimeout(r, 60 * 1000));
-            if (!__classPrivateFieldGet(this, _Client_lastOutgoing, "f") || (Date.now() - __classPrivateFieldGet(this, _Client_lastOutgoing, "f").getTime() < 60 * 1000)) {
-                continue;
-            }
+            await new Promise((r) => setTimeout(r, __classPrivateFieldGet(this, _Client_pingInterval, "f")));
             try {
-                await this.invoke(new functions.Ping({ pingId: getRandomBigInt(8, true, false) }));
+                await this.invoke(new functions.PingDelayDisconnect({ pingId: getRandomBigInt(8, true, false), disconnectDelay: __classPrivateFieldGet(this, _Client_pingInterval, "f") + 15 }));
             }
             catch (err) {
                 d("ping loop error: %o", err);
             }
         }
+    }, _Client_invoke = async function _Client_invoke(function_, noWait) {
+        if (!__classPrivateFieldGet(this, _Client_auth, "f") || !this.transport) {
+            if (__classPrivateFieldGet(this, _Client_autoStart, "f") && !__classPrivateFieldGet(this, _Client_autoStarted, "f")) {
+                await this.start();
+            }
+            else {
+                throw new ConnectionError("Not connected");
+            }
+        }
+        if (!__classPrivateFieldGet(this, _Client_auth, "f") || !this.transport) {
+            UNREACHABLE();
+        }
+        let n = 1;
+        while (true) {
+            try {
+                let seqNo = __classPrivateFieldGet(this, _Client_state, "f").seqNo * 2;
+                if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
+                    seqNo++;
+                    __classPrivateFieldGet(this, _Client_state, "f").seqNo++;
+                }
+                const messageId = __classPrivateFieldSet(this, _Client_lastMsgId, getMessageId(__classPrivateFieldGet(this, _Client_lastMsgId, "f")), "f");
+                const message = new Message_(messageId, seqNo, function_);
+                await this.transport.transport.send(await encryptMessage(message, __classPrivateFieldGet(this, _Client_auth, "f").key, __classPrivateFieldGet(this, _Client_auth, "f").id, __classPrivateFieldGet(this, _Client_state, "f").salt, __classPrivateFieldGet(this, _Client_sessionId, "f")));
+                d("invoked %s", function_.constructor.name);
+                if (noWait) {
+                    __classPrivateFieldGet(this, _Client_promises, "f").set(message.id, {
+                        resolve: (result) => {
+                            if (result instanceof types.BadServerSalt) {
+                                drop(this.invoke(function_, true));
+                            }
+                        },
+                        reject: () => { },
+                    });
+                    return;
+                }
+                let result;
+                try {
+                    result = await new Promise((resolve, reject) => {
+                        __classPrivateFieldGet(this, _Client_promises, "f").set(message.id, { resolve, reject });
+                    });
+                }
+                catch (err) {
+                    if (err instanceof AuthKeyUnregistered) {
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateAuthorizationState).call(this, false);
+                    }
+                    throw err;
+                }
+                if (result instanceof types.BadServerSalt) {
+                    return await this.invoke(function_);
+                }
+                else {
+                    if (!__classPrivateFieldGet(this, _Client_pingLoopStarted, "f")) {
+                        drop(__classPrivateFieldGet(this, _Client_instances, "m", _Client_pingLoop).call(this));
+                        __classPrivateFieldSet(this, _Client_pingLoopStarted, true, "f");
+                    }
+                    return result;
+                }
+            }
+            catch (err) {
+                if (await __classPrivateFieldGet(this, _Client_handleInvokeError, "f").call(this, Object.freeze({ client: this, error: err, function: function_, n: n++ }), () => Promise.resolve(false))) {
+                    continue;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
     }, _Client_processChats = async function _Client_processChats(chats) {
         for (const chat of chats) {
             if (chat instanceof types.Channel && chat.accessHash) {
@@ -908,7 +1073,7 @@ export class Client extends ClientAbstract {
         return localState;
     }, _Client_recoverUpdateGap = async function _Client_recoverUpdateGap(source) {
         dGap("recovering from update gap [%s]", source);
-        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateConnectionState).call(this, "updating");
+        __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateConnectionState).call(this, "updating");
         try {
             let state = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getLocalState).call(this);
             while (true) {
@@ -1685,20 +1850,15 @@ export class Client extends ClientAbstract {
             nextOffset: params?.nextOffset,
         }));
     }
-    use(handler) {
-        const handle = __classPrivateFieldGet(this, _Client_handle, "f");
-        __classPrivateFieldSet(this, _Client_handle, async (upd, next) => {
-            let called = false;
-            await handle(upd, async () => {
-                if (called)
-                    return;
-                called = true;
-                await handler(upd, next);
-            });
-        }, "f");
+    use(...middleware) {
+        const composer = new Composer(...middleware);
+        __classPrivateFieldSet(this, _Client_handle, concat(__classPrivateFieldGet(this, _Client_handle, "f"), flatten(composer)), "f");
+        return composer;
     }
-    branch(predicate, trueHandler, falseHandler) {
-        this.use(async (upd, next) => {
+    branch(predicate, trueHandler_, falseHandler_) {
+        const trueHandler = flatten(trueHandler_);
+        const falseHandler = flatten(falseHandler_);
+        return this.use(async (upd, next) => {
             if (await predicate(upd)) {
                 await trueHandler(upd, next);
             }
@@ -1707,19 +1867,19 @@ export class Client extends ClientAbstract {
             }
         });
     }
-    filter(predicate, handler) {
-        this.branch(predicate, handler, skip);
+    filter(predicate, ...middleware) {
+        return this.branch(predicate, middleware.length == 0 ? skip : middleware.map(flatten).reduce(concat), skip);
     }
-    on(filter, handler) {
+    on(filter, ...middleawre) {
         const type = typeof filter === "string" ? filter : filter[0];
         const keys = Array.isArray(filter) ? filter.slice(1) : [];
-        this.filter((update) => {
-            if (type in update) {
+        return this.filter((ctx) => {
+            if (type in ctx) {
                 if (keys.length > 0) {
                     for (const key of keys) {
                         // deno-lint-ignore ban-ts-comment
                         // @ts-ignore
-                        if (!(key in update[type])) {
+                        if (!(key in ctx[type])) {
                             return false;
                         }
                     }
@@ -1729,7 +1889,7 @@ export class Client extends ClientAbstract {
             else {
                 return false;
             }
-        }, handler);
+        }, ...middleawre);
     }
     /**
      * Set the bot's description in the given language. Bot-only.
@@ -1785,6 +1945,104 @@ export class Client extends ClientAbstract {
         await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "getMyShortDescription");
         return await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getMyInfo).call(this, params?.languageCode).then((v) => v.about);
     }
+    /**
+     * Delete multiple messages.
+     *
+     * @method
+     * @param chatId The chat that contains the messages.
+     * @param messageIds The identifier of the messages to delete.
+     */
+    async deleteMessages(chatId, messageIds, params) {
+        const peer = await this.getInputPeer(chatId);
+        if (peer instanceof types.InputPeerChannel) {
+            await this.invoke(new functions.ChannelsDeleteMessages({ channel: new types.InputChannel(peer), id: messageIds }));
+        }
+        else {
+            await this.invoke(new functions.MessagesDeleteMessages({ id: messageIds, revoke: params?.onlyForMe ? undefined : true }));
+        }
+    }
+    /**
+     * Delete a single message.
+     *
+     * @method
+     * @param chatId The chat that contains the message.
+     * @param messageId The identifier of the message to delete.
+     */
+    async deleteMessage(chatId, messageId, params) {
+        await this.deleteMessages(chatId, [messageId], params);
+    }
+    /**
+     * Send a photo.
+     *
+     * @method
+     * @param chatId The chat to send the photo to.
+     * @param photo The photo to send.
+     */
+    async sendPhoto(chatId, photo, params) {
+        let media = null;
+        const spoiler = params?.hasSpoiler ? true : undefined;
+        if (typeof photo === "string") {
+            let fileId = null;
+            try {
+                fileId = FileID.decode(photo);
+            }
+            catch (err) {
+                d("fileId: %o", err);
+            }
+            if (fileId != null) {
+                if (fileId.fileType != FileType.Photo) {
+                    UNREACHABLE();
+                }
+                if (fileId.params.mediaId == undefined || fileId.params.accessHash == undefined || fileId.params.fileReference == undefined) {
+                    UNREACHABLE();
+                }
+                media = new types.InputMediaPhoto({
+                    id: new types.InputPhoto({
+                        id: fileId.params.mediaId,
+                        accessHash: fileId.params.accessHash,
+                        fileReference: fileId.params.fileReference,
+                    }),
+                    spoiler,
+                });
+            }
+        }
+        if (media == null) {
+            if (typeof photo === "string" && isHttpUrl(photo)) {
+                media = new types.InputMediaPhotoExternal({ url: photo, spoiler });
+            }
+            else {
+                const [contents, fileName] = await getFileContents(photo);
+                const file = await this.upload(contents, { fileName, chunkSize: params?.chunkSize, signal: params?.signal });
+                media = new types.InputMediaUploadedPhoto({ file, spoiler });
+            }
+        }
+        const peer = await this.getInputPeer(chatId);
+        const randomId = getRandomId();
+        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; // TODO: check default sendAs
+        const replyMarkup = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_constructReplyMarkup).call(this, params);
+        const caption_ = params?.caption;
+        const parseResult = caption_ !== undefined ? __classPrivateFieldGet(this, _Client_instances, "m", _Client_parseText).call(this, caption_, { parseMode: params?.parseMode, entities: params?.captionEntities }) : undefined;
+        const caption = parseResult === undefined ? undefined : parseResult[0];
+        const captionEntities = parseResult === undefined ? undefined : parseResult[1];
+        const result = await this.invoke(new functions.MessagesSendMedia({
+            peer,
+            randomId,
+            silent,
+            noforwards,
+            replyMarkup,
+            replyTo: replyToMsgId !== undefined ? new types.InputReplyToMessage({ replyToMsgId, topMsgId }) : undefined,
+            sendAs,
+            media,
+            message: caption ?? "",
+            entities: captionEntities,
+        }));
+        const message = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return __classPrivateFieldGet(Client, _a, "m", _Client_assertMsgHas).call(Client, message, "photo");
+    }
 }
 _a = Client, _Client_handleUpdate = 
 // TODO: log errors
@@ -1845,7 +2103,7 @@ async function _Client_handleUpdate(update) {
         const key = update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage ? "message" : "editedMessage";
         if (!(update.message instanceof types.MessageEmpty)) {
             const message = await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this));
-            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { [key]: message }, resolve);
+            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, __classPrivateFieldGet(this, _Client_constructContext, "f").call(this, { [key]: message }), resolve);
         }
     }
     if (update instanceof types.UpdateDeleteMessages) {
@@ -1861,7 +2119,7 @@ async function _Client_handleUpdate(update) {
             }
         }
         if (deletedMessages.length > 0) {
-            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { deletedMessages: deletedMessages }, resolve);
+            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, __classPrivateFieldGet(this, _Client_constructContext, "f").call(this, { deletedMessages: deletedMessages }), resolve);
         }
     }
     else if (update instanceof types.UpdateDeleteChannelMessages) {
@@ -1875,14 +2133,14 @@ async function _Client_handleUpdate(update) {
             await this.storage.setMessage(chatId, messageId, null);
         }
         if (deletedMessages.length > 0) {
-            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { deletedMessages: deletedMessages }, resolve);
+            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, __classPrivateFieldGet(this, _Client_constructContext, "f").call(this, { deletedMessages: deletedMessages }), resolve);
         }
     }
     if (update instanceof types.UpdateBotCallbackQuery || update instanceof types.UpdateInlineBotCallbackQuery) {
-        await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { callbackQuery: await constructCallbackQuery(update, this[getEntity].bind(this), this[getMessageWithReply].bind(this)) }, resolve);
+        await __classPrivateFieldGet(this, _Client_handle, "f").call(this, __classPrivateFieldGet(this, _Client_constructContext, "f").call(this, { callbackQuery: await constructCallbackQuery(update, this[getEntity].bind(this), this[getMessageWithReply].bind(this)) }), resolve);
     }
     else if (update instanceof types.UpdateBotInlineQuery) {
-        await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { inlineQuery: await constructInlineQuery(update, this[getEntity].bind(this)) }, resolve);
+        await __classPrivateFieldGet(this, _Client_handle, "f").call(this, __classPrivateFieldGet(this, _Client_constructContext, "f").call(this, { inlineQuery: await constructInlineQuery(update, this[getEntity].bind(this)) }), resolve);
     }
 }, _Client_constructReplyMarkup = async function _Client_constructReplyMarkup(params) {
     if (params?.replyMarkup) {
@@ -1894,7 +2152,9 @@ async function _Client_handleUpdate(update) {
         UNREACHABLE();
     }
     return message;
-}, _Client_setMyInfo = async function _Client_setMyInfo(info) {
+}, _Client_setMyInfo = 
+//#endregion
+async function _Client_setMyInfo(info) {
     await this.invoke(new functions.BotsSetBotInfo({ bot: new types.InputUserSelf(), ...info }));
 }, _Client_getMyInfo = function _Client_getMyInfo(languageCode) {
     return this.invoke(new functions.BotsGetBotInfo({ bot: new types.InputUserSelf(), langCode: languageCode ?? "" }));

package/esm/client/6_composer.d.ts

@@ -0,0 +1,4 @@
+import { Composer as Composer_ } from "./4_composer.js";
+import { Context } from "./5_client.js";
+export declare class Composer<C extends Context = Context> extends Composer_<C> {
+}