@mtkruto/node 0.1.111 → 0.1.113

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";
@@ -23,7 +23,7 @@ import { checkPassword } from "./0_password.js";
 import { isChannelPtsUpdate, 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,81 @@ 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;
+            return {
+                ...update,
+                client: this,
+                msg,
+                chat,
+                from,
+                senderChat,
+                reply: (text, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    const shouldQuote = params?.quote === undefined ? effectiveMessage.chat.type != "private" : params.quote;
+                    return this.sendMessage(effectiveMessage.chat.id, text, { ...params, replyToMessageId: shouldQuote ? effectiveMessage.id : undefined });
+                },
+                replyPoll: (question, options, params) => {
+                    const effectiveMessage = mustGetMsg();
+                    return this.sendPoll(effectiveMessage.chat.id, question, options, 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);
+                },
+                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 +209,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 +257,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 +358,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 +598,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 +652,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 +772,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 +1038,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) {
@@ -1196,6 +1326,9 @@ export class Client extends ClientAbstract {
         const messages = new Array();
         if (updates instanceof types.Updates) {
             for (const update of updates.updates) {
+                if ("message" in update && update.message instanceof types.MessageEmpty) {
+                    continue;
+                }
                 if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateEditMessage) {
                     messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
                 }
@@ -1267,6 +1400,9 @@ export class Client extends ClientAbstract {
         }
         const messages = new Array();
         for (const message_ of messages_) {
+            if (message_ instanceof types.MessageEmpty) {
+                continue;
+            }
             const message = await constructMessage(message_, this[getEntity].bind(this), null, this[getStickerSetName].bind(this));
             const isReplyToMessage = message_ instanceof types.Message && message_.replyTo instanceof types.MessageReplyHeader;
             messages.push({ message, isReplyToMessage });
@@ -1679,20 +1815,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);
             }
@@ -1701,19 +1832,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;
                         }
                     }
@@ -1723,7 +1854,7 @@ export class Client extends ClientAbstract {
             else {
                 return false;
             }
-        }, handler);
+        }, ...middleawre);
     }
     /**
      * Set the bot's description in the given language. Bot-only.
@@ -1837,8 +1968,10 @@ async function _Client_handleUpdate(update) {
         update instanceof types.UpdateEditMessage ||
         update instanceof types.UpdateEditChannelMessage) {
         const key = update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage ? "message" : "editedMessage";
-        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);
+        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, __classPrivateFieldGet(this, _Client_constructContext, "f").call(this, { [key]: message }), resolve);
+        }
     }
     if (update instanceof types.UpdateDeleteMessages) {
         const deletedMessages = new Array();
@@ -1846,14 +1979,14 @@ async function _Client_handleUpdate(update) {
             const chatId = await this.storage.getMessageChat(messageId);
             if (chatId) {
                 const message = await this.storage.getMessage(chatId, messageId);
-                if (message != null) {
+                if (message != null && !(message instanceof types.MessageEmpty)) {
                     deletedMessages.push(await constructMessage(message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
                 }
                 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);
         }
     }
     else if (update instanceof types.UpdateDeleteChannelMessages) {
@@ -1861,20 +1994,20 @@ async function _Client_handleUpdate(update) {
         const deletedMessages = new Array();
         for (const messageId of update.messages) {
             const message = await this.storage.getMessage(chatId, messageId);
-            if (message) {
+            if (message != null && !(message instanceof types.MessageEmpty)) {
                 deletedMessages.push(await constructMessage(message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
             }
             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) {
@@ -1886,7 +2019,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> {
+}

package/esm/client/6_composer.js

@@ -0,0 +1,3 @@
+import { Composer as Composer_ } from "./4_composer.js";
+export class Composer extends Composer_ {
+}

package/esm/tl/0_tl_raw_reader.d.ts

@@ -8,6 +8,7 @@ export declare class TLRawReader {
     readInt24(signed?: boolean): number;
     readInt32(signed?: boolean): number;
     readInt64(signed?: boolean): bigint;
+    readDouble(): number;
     readInt128(signed?: boolean): bigint;
     readInt256(signed?: boolean): bigint;
     readBytes(): Uint8Array;

package/esm/tl/0_tl_raw_reader.js

@@ -33,6 +33,9 @@ export class TLRawReader {
         const buffer = this.read(64 / 8);
         return bigIntFromBuffer(buffer, true, signed);
     }
+    readDouble() {
+        return new DataView(this.read(8).buffer).getFloat64(0, true); // TODO: cover in tests
+    }
     readInt128(signed = true) {
         const buffer = this.read(128 / 8);
         return bigIntFromBuffer(buffer, true, signed);

package/esm/tl/3_deserialize.js

@@ -28,7 +28,12 @@ function deserializeSingleParam(reader, type, ntype) {
             case "boolean":
                 return reader.readInt32(false) == 0x997275B5;
             case "number":
-                return reader.readInt32();
+                if (ntype == "double") {
+                    return reader.readDouble();
+                }
+                else {
+                    return reader.readInt32();
+                }
             case "string":
                 return reader.readString();
             case "true":
@@ -64,7 +69,7 @@ export function deserialize(reader, paramDesc, constructor) {
             continue;
         }
         const value = deserializeSingleParam(reader, type, ntype);
-        if (value) {
+        if (typeof value !== "boolean" || value) {
             params[name] = value;
         }
     }