@mtkruto/browser 0.119.0 → 0.120.0

package/esm/session/2_session_encrypted.js

@@ -17,18 +17,6 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-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 _SessionEncrypted_instances, _a, _SessionEncrypted_TGCRYPTO_INITED, _SessionEncrypted_id, _SessionEncrypted_L, _SessionEncrypted_LsendLoop, _SessionEncrypted_LreceiveLoop, _SessionEncrypted_LpingLoop, _SessionEncrypted_authKey, _SessionEncrypted_authKeyId, _SessionEncrypted_sentMessages, _SessionEncrypted_pendingMessages, _SessionEncrypted_containers, _SessionEncrypted_pendingPings, _SessionEncrypted_toAcknowledge, _SessionEncrypted_pendingAcks, _SessionEncrypted_assertNotDisconnected, _SessionEncrypted_invalidateSession, _SessionEncrypted_rejectAllPending, _SessionEncrypted_onMessageFailed, _SessionEncrypted_setServerSalt, _SessionEncrypted_receive, _SessionEncrypted_encryptMessage, _SessionEncrypted_decryptMessage, _SessionEncrypted_awakeSendLoop, _SessionEncrypted_sendLoop, _SessionEncrypted_sendLoopBody, _SessionEncrypted_receiveLoop, _SessionEncrypted_receiveLoopBody, _SessionEncrypted_onMessage, _SessionEncrypted_onRpcResult, _SessionEncrypted_onMsgDetailedInfo, _SessionEncrypted_onMsgNewDetailedInfo, _SessionEncrypted_onBadMsgNotification, _SessionEncrypted_onBadServerSalt, _SessionEncrypted_onPong, _SessionEncrypted_onNewSessionCreated, _SessionEncrypted_onMessageContainer, _SessionEncrypted_pingInterval, _SessionEncrypted_pingLoop, _SessionEncrypted_timeElapsed, _SessionEncrypted_pingLoopBody, _SessionEncrypted_sendPingDelayDisconnect, _SessionEncrypted_resendPendingPing;
 import { assertEquals, concat, delay, ige256Decrypt, ige256Encrypt, initTgCrypto, LruCache, SECOND } from "../0_deps.js";
 import { ConnectionError, TransportError } from "../0_errors.js";
 import { drop, getLogger, getRandomId, gunzip, intFromBytes, intToBytes, mod, sha1, sha256, toUnixTimestamp } from "../1_utilities.js";
@@ -43,465 +31,479 @@ const GZIP_PACKED = 0x3072CFA1;
 const RPC_RESULT = 0xF35C6D01;
 const RPC_ERROR = Mtproto.schema.definitions["rpc_error"][0];
 export class SessionEncrypted extends Session {
+    static #TGCRYPTO_INITED = false;
+    #id = getRandomId();
+    handlers = {};
+    #L;
+    #LsendLoop;
+    #LreceiveLoop;
+    #LpingLoop;
+    #authKey = new Uint8Array();
+    #authKeyId = 0n;
+    #sentMessages = new Set();
+    #pendingMessages = new Array();
+    #containers = new LruCache(20_000);
+    #pendingPings = new Map();
+    #toAcknowledge = new Array();
+    #pendingAcks = new LruCache(100);
     constructor(dc, params) {
         super(dc, params);
-        _SessionEncrypted_instances.add(this);
-        _SessionEncrypted_id.set(this, getRandomId());
-        Object.defineProperty(this, "handlers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        _SessionEncrypted_L.set(this, void 0);
-        _SessionEncrypted_LsendLoop.set(this, void 0);
-        _SessionEncrypted_LreceiveLoop.set(this, void 0);
-        _SessionEncrypted_LpingLoop.set(this, void 0);
-        _SessionEncrypted_authKey.set(this, new Uint8Array());
-        _SessionEncrypted_authKeyId.set(this, 0n);
-        _SessionEncrypted_sentMessages.set(this, new Set());
-        _SessionEncrypted_pendingMessages.set(this, new Array());
-        _SessionEncrypted_containers.set(this, new LruCache(20_000));
-        _SessionEncrypted_pendingPings.set(this, new Map());
-        _SessionEncrypted_toAcknowledge.set(this, new Array());
-        _SessionEncrypted_pendingAcks.set(this, new LruCache(100));
-        //// SEND LOOP ////
-        _SessionEncrypted_awakeSendLoop.set(this, void 0);
-        _SessionEncrypted_sendLoop.set(this, new AbortableLoop(__classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_sendLoopBody).bind(this), (err) => {
-            __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").error("unhandled receive loop error:", err);
-        }));
-        //// RECEIVE LOOP ////
-        _SessionEncrypted_receiveLoop.set(this, new AbortableLoop(__classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_receiveLoopBody).bind(this), (err) => {
-            __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").error("unhandled receive loop error:", err);
-        }));
-        //// PING LOOP ////
-        _SessionEncrypted_pingInterval.set(this, 56 * SECOND);
-        _SessionEncrypted_pingLoop.set(this, new AbortableLoop(__classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_pingLoopBody).bind(this), (_, err) => {
-            __classPrivateFieldGet(this, _SessionEncrypted_LpingLoop, "f").error(err);
-        }));
-        _SessionEncrypted_timeElapsed.set(this, 0);
-        const L = __classPrivateFieldSet(this, _SessionEncrypted_L, getLogger("SessionEncrypted").client(id++), "f");
-        __classPrivateFieldSet(this, _SessionEncrypted_LsendLoop, L.branch("sendLoop"), "f");
-        __classPrivateFieldSet(this, _SessionEncrypted_LreceiveLoop, L.branch("receiveLoop"), "f");
-        __classPrivateFieldSet(this, _SessionEncrypted_LpingLoop, L.branch("pingLoop"), "f");
+        const L = this.#L = getLogger("SessionEncrypted").client(id++);
+        this.#LsendLoop = L.branch("sendLoop");
+        this.#LreceiveLoop = L.branch("receiveLoop");
+        this.#LpingLoop = L.branch("pingLoop");
     }
     async setAuthKey(key) {
         const hash = await sha1(key);
-        __classPrivateFieldSet(this, _SessionEncrypted_authKeyId, intFromBytes(hash.slice(-8)), "f");
-        __classPrivateFieldSet(this, _SessionEncrypted_authKey, key, "f");
+        this.#authKeyId = intFromBytes(hash.slice(-8));
+        this.#authKey = key;
     }
     get authKey() {
-        return __classPrivateFieldGet(this, _SessionEncrypted_authKey, "f");
+        return this.#authKey;
     }
     async connect() {
         if (!this.isConnected) {
-            __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_rejectAllPending).call(this, new ConnectionError("The connection was closed."));
+            this.#rejectAllPending(new ConnectionError("The connection was closed."));
         }
         await super.connect();
-        if (!__classPrivateFieldGet(_a, _a, "f", _SessionEncrypted_TGCRYPTO_INITED)) {
+        if (!SessionEncrypted.#TGCRYPTO_INITED) {
             await initTgCrypto();
-            __classPrivateFieldSet(_a, _a, true, "f", _SessionEncrypted_TGCRYPTO_INITED);
+            SessionEncrypted.#TGCRYPTO_INITED = true;
         }
-        __classPrivateFieldGet(this, _SessionEncrypted_receiveLoop, "f").start();
-        __classPrivateFieldGet(this, _SessionEncrypted_sendLoop, "f").start();
-        __classPrivateFieldGet(this, _SessionEncrypted_pingLoop, "f").start();
-        __classPrivateFieldGet(this, _SessionEncrypted_awakeSendLoop, "f")?.call(this);
+        this.#receiveLoop.start();
+        this.#sendLoop.start();
+        this.#pingLoop.start();
+        this.#awakeSendLoop?.();
     }
     disconnect() {
         super.disconnect();
         this.state.reset();
-        __classPrivateFieldSet(this, _SessionEncrypted_id, getRandomId(), "f");
-        __classPrivateFieldGet(this, _SessionEncrypted_pingLoop, "f").abort();
-        __classPrivateFieldGet(this, _SessionEncrypted_awakeSendLoop, "f")?.call(this);
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_rejectAllPending).call(this, new ConnectionError("The connection was disconnected."));
+        this.#id = getRandomId();
+        this.#pingLoop.abort();
+        this.#awakeSendLoop?.();
+        this.#rejectAllPending(new ConnectionError("The connection was disconnected."));
+    }
+    #assertNotDisconnected() {
+        if (this.isDisconnected) {
+            throw new ConnectionError("The connection was disconnected.");
+        }
+    }
+    async #invalidateSession(reason) {
+        this.#L.debug("invalidating session because of", reason);
+        this.#id = getRandomId();
+        this.state.reset();
+        this.disconnect();
+        await this.connect();
+        this.#rejectAllPending(new SessionError("The session was invalidated."));
+    }
+    #rejectAllPending(reason) {
+        for (const id of this.#sentMessages) {
+            this.#onMessageFailed(id, reason);
+        }
+        for (const pendingPing of this.#pendingPings.values()) {
+            pendingPing.promiseWithResolvers.reject(reason);
+        }
+        this.#sentMessages.clear();
+        this.#pendingPings.clear();
+        this.#containers.clear();
+    }
+    #onMessageFailed(id, reason) {
+        this.#sentMessages.delete(id);
+        const pendingContainer = this.#containers.get(id);
+        if (pendingContainer) {
+            for (const id of pendingContainer) {
+                this.#onMessageFailed(id, reason);
+            }
+            this.#containers.delete(id);
+            return;
+        }
+        const pendingAck = this.#pendingAcks.get(id);
+        if (pendingAck) {
+            for (const id of pendingAck) {
+                this.#toAcknowledge.push(id);
+            }
+            this.#pendingAcks.delete(id);
+            return;
+        }
+        const pendingPing = this.#pendingPings.get(id);
+        if (pendingPing) {
+            this.#pendingPings.delete(id);
+            if (reason instanceof SessionError) {
+                drop(this.#resendPendingPing(pendingPing));
+            }
+            else {
+                pendingPing.promiseWithResolvers.reject(reason);
+            }
+            return;
+        }
+        // message was not sent by us
+        this.handlers.onMessageFailed?.(id, reason);
+    }
+    #setServerSalt(newServerSalt) {
+        this.state.serverSalt = newServerSalt;
+        this.handlers.onNewServerSalt?.(newServerSalt);
     }
     async send(body) {
         if (!this.isDisconnected && !this.isConnected) {
             await super.waitUntilConnected();
         }
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_assertNotDisconnected).call(this);
+        this.#assertNotDisconnected();
         const pendingMessage = { body, promiseWithResolvers: Promise.withResolvers() };
-        __classPrivateFieldGet(this, _SessionEncrypted_pendingMessages, "f").push(pendingMessage);
-        __classPrivateFieldGet(this, _SessionEncrypted_awakeSendLoop, "f")?.call(this);
+        this.#pendingMessages.push(pendingMessage);
+        this.#awakeSendLoop?.();
         return await pendingMessage.promiseWithResolvers.promise;
     }
-}
-_a = SessionEncrypted, _SessionEncrypted_id = new WeakMap(), _SessionEncrypted_L = new WeakMap(), _SessionEncrypted_LsendLoop = new WeakMap(), _SessionEncrypted_LreceiveLoop = new WeakMap(), _SessionEncrypted_LpingLoop = new WeakMap(), _SessionEncrypted_authKey = new WeakMap(), _SessionEncrypted_authKeyId = new WeakMap(), _SessionEncrypted_sentMessages = new WeakMap(), _SessionEncrypted_pendingMessages = new WeakMap(), _SessionEncrypted_containers = new WeakMap(), _SessionEncrypted_pendingPings = new WeakMap(), _SessionEncrypted_toAcknowledge = new WeakMap(), _SessionEncrypted_pendingAcks = new WeakMap(), _SessionEncrypted_awakeSendLoop = new WeakMap(), _SessionEncrypted_sendLoop = new WeakMap(), _SessionEncrypted_receiveLoop = new WeakMap(), _SessionEncrypted_pingInterval = new WeakMap(), _SessionEncrypted_pingLoop = new WeakMap(), _SessionEncrypted_timeElapsed = new WeakMap(), _SessionEncrypted_instances = new WeakSet(), _SessionEncrypted_assertNotDisconnected = function _SessionEncrypted_assertNotDisconnected() {
-    if (this.isDisconnected) {
-        throw new ConnectionError("The connection was disconnected.");
-    }
-}, _SessionEncrypted_invalidateSession = async function _SessionEncrypted_invalidateSession(reason) {
-    __classPrivateFieldGet(this, _SessionEncrypted_L, "f").debug("invalidating session because of", reason);
-    __classPrivateFieldSet(this, _SessionEncrypted_id, getRandomId(), "f");
-    this.state.reset();
-    this.disconnect();
-    await this.connect();
-    __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_rejectAllPending).call(this, new SessionError("The session was invalidated."));
-}, _SessionEncrypted_rejectAllPending = function _SessionEncrypted_rejectAllPending(reason) {
-    for (const id of __classPrivateFieldGet(this, _SessionEncrypted_sentMessages, "f")) {
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMessageFailed).call(this, id, reason);
-    }
-    for (const pendingPing of __classPrivateFieldGet(this, _SessionEncrypted_pendingPings, "f").values()) {
-        pendingPing.promiseWithResolvers.reject(reason);
-    }
-    __classPrivateFieldGet(this, _SessionEncrypted_sentMessages, "f").clear();
-    __classPrivateFieldGet(this, _SessionEncrypted_pendingPings, "f").clear();
-    __classPrivateFieldGet(this, _SessionEncrypted_containers, "f").clear();
-}, _SessionEncrypted_onMessageFailed = function _SessionEncrypted_onMessageFailed(id, reason) {
-    __classPrivateFieldGet(this, _SessionEncrypted_sentMessages, "f").delete(id);
-    const pendingContainer = __classPrivateFieldGet(this, _SessionEncrypted_containers, "f").get(id);
-    if (pendingContainer) {
-        for (const id of pendingContainer) {
-            __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMessageFailed).call(this, id, reason);
-        }
-        __classPrivateFieldGet(this, _SessionEncrypted_containers, "f").delete(id);
-        return;
-    }
-    const pendingAck = __classPrivateFieldGet(this, _SessionEncrypted_pendingAcks, "f").get(id);
-    if (pendingAck) {
-        for (const id of pendingAck) {
-            __classPrivateFieldGet(this, _SessionEncrypted_toAcknowledge, "f").push(id);
+    async #receive() {
+        this.#assertNotDisconnected();
+        const buffer = await this.transport.transport.receive();
+        if (buffer.length === 4) {
+            const int = intFromBytes(buffer);
+            throw new TransportError(Number(int));
         }
-        __classPrivateFieldGet(this, _SessionEncrypted_pendingAcks, "f").delete(id);
-        return;
-    }
-    const pendingPing = __classPrivateFieldGet(this, _SessionEncrypted_pendingPings, "f").get(id);
-    if (pendingPing) {
-        __classPrivateFieldGet(this, _SessionEncrypted_pendingPings, "f").delete(id);
-        if (reason instanceof SessionError) {
-            drop(__classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_resendPendingPing).call(this, pendingPing));
+        try {
+            const decrypted = await this.#decryptMessage(buffer);
+            this.#L.in(decrypted);
+            return decrypted;
         }
-        else {
-            pendingPing.promiseWithResolvers.reject(reason);
+        catch (err) {
+            this.#L.error("decryption error:", err);
+            await this.#invalidateSession("decryption error");
+            throw err;
         }
-        return;
-    }
-    // message was not sent by us
-    this.handlers.onMessageFailed?.(id, reason);
-}, _SessionEncrypted_setServerSalt = function _SessionEncrypted_setServerSalt(newServerSalt) {
-    this.state.serverSalt = newServerSalt;
-    this.handlers.onNewServerSalt?.(newServerSalt);
-}, _SessionEncrypted_receive = async function _SessionEncrypted_receive() {
-    __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_assertNotDisconnected).call(this);
-    const buffer = await this.transport.transport.receive();
-    if (buffer.length === 4) {
-        const int = intFromBytes(buffer);
-        throw new TransportError(Number(int));
-    }
-    try {
-        const decrypted = await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_decryptMessage).call(this, buffer);
-        __classPrivateFieldGet(this, _SessionEncrypted_L, "f").in(decrypted);
-        return decrypted;
-    }
-    catch (err) {
-        __classPrivateFieldGet(this, _SessionEncrypted_L, "f").error("decryption error:", err);
-        await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_invalidateSession).call(this, "decryption error");
-        throw err;
     }
-}, _SessionEncrypted_encryptMessage = async function _SessionEncrypted_encryptMessage(message) {
-    const payloadWriter = new TLWriter();
-    payloadWriter.writeInt64(this.state.serverSalt);
-    payloadWriter.writeInt64(__classPrivateFieldGet(this, _SessionEncrypted_id, "f"));
-    payloadWriter.write(await serializeMessage(message));
-    payloadWriter.write(new Uint8Array(mod(-(payloadWriter.buffer.length + 12), 16) + 12));
-    const payload = payloadWriter.buffer;
-    const messageKey = (await sha256(concat([__classPrivateFieldGet(this, _SessionEncrypted_authKey, "f").subarray(88, 120), payload]))).subarray(8, 24);
-    const a = await sha256(concat([messageKey, __classPrivateFieldGet(this, _SessionEncrypted_authKey, "f").subarray(0, 36)]));
-    const b = await sha256(concat([__classPrivateFieldGet(this, _SessionEncrypted_authKey, "f").subarray(40, 76), messageKey]));
-    const aesKey = concat([a.subarray(0, 8), b.subarray(8, 24), a.subarray(24, 32)]);
-    const aesIV = concat([b.subarray(0, 8), a.subarray(8, 24), b.subarray(24, 32)]);
-    const messageWriter = new TLWriter();
-    messageWriter.writeInt64(__classPrivateFieldGet(this, _SessionEncrypted_authKeyId, "f"));
-    messageWriter.write(messageKey);
-    messageWriter.write(ige256Encrypt(payload, aesKey, aesIV));
-    return messageWriter.buffer;
-}, _SessionEncrypted_decryptMessage = async function _SessionEncrypted_decryptMessage(buffer) {
-    const reader = new TLReader(buffer);
-    assertEquals(reader.readInt64(), __classPrivateFieldGet(this, _SessionEncrypted_authKeyId, "f"));
-    const messageKey_ = reader.readInt128();
-    const messageKey = intToBytes(messageKey_, 16);
-    const a = await sha256(concat([messageKey, __classPrivateFieldGet(this, _SessionEncrypted_authKey, "f").subarray(8, 44)]));
-    const b = await sha256(concat([__classPrivateFieldGet(this, _SessionEncrypted_authKey, "f").subarray(48, 84), messageKey]));
-    const aesKey = concat([a.subarray(0, 8), b.subarray(8, 24), a.subarray(24, 32)]);
-    const aesIv = concat([b.subarray(0, 8), a.subarray(8, 24), b.subarray(24, 32)]);
-    const plaintext = ige256Decrypt(reader.buffer, aesKey, aesIv);
-    assertEquals(plaintext.buffer.byteLength % 4, 0);
-    const plainReader = new TLReader(plaintext);
-    const _salt = plainReader.readInt64();
-    const _sessionId_ = plainReader.readInt64(false);
-    return deserializeMessage(plainReader);
-}, _SessionEncrypted_sendLoopBody = async function _SessionEncrypted_sendLoopBody(loop, signal) {
-    if (!this.isConnected) {
-        __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("aborting as not connected");
-        loop.abort();
-        return;
-    }
-    const pendingMessage = __classPrivateFieldGet(this, _SessionEncrypted_pendingMessages, "f").shift();
-    if (pendingMessage === undefined) {
-        __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("no pending messages");
-        return await new Promise((resolve) => {
-            const onAbort = () => {
-                __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("got aborted while sleeping");
-                resolve();
-            };
-            signal.addEventListener("abort", onAbort);
-            __classPrivateFieldSet(this, _SessionEncrypted_awakeSendLoop, () => {
-                __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("got awaken");
-                resolve();
-                signal.removeEventListener("abort", onAbort);
-            }, "f");
-        });
-    }
-    const msg_id = this.state.nextMessageId();
-    const seqno = this.state.nextSeqNo(true);
-    let message = {
-        _: "message",
-        msg_id,
-        seqno,
-        body: pendingMessage.body,
-    };
-    __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("msg_id =", msg_id, "seqno =", seqno);
-    if (__classPrivateFieldGet(this, _SessionEncrypted_toAcknowledge, "f").length) {
-        const msg_ids = __classPrivateFieldGet(this, _SessionEncrypted_toAcknowledge, "f").splice(0, 8192);
-        __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("acknowledging", msg_ids.length, "message(s) while sending this one");
-        const ack = {
-            _: "message",
-            msg_id: this.state.nextMessageId(),
-            seqno: this.state.nextSeqNo(false),
-            body: Mtproto.serializeObject({ _: "msgs_ack", msg_ids }),
-        };
-        __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("msgs_ack msg_id =", ack.msg_id, "seqno =", seqno);
-        __classPrivateFieldGet(this, _SessionEncrypted_pendingAcks, "f").set(ack.msg_id, msg_ids);
-        message = {
-            _: "message",
-            msg_id: this.state.nextMessageId(),
-            seqno: this.state.nextSeqNo(false),
-            body: {
-                _: "msg_container",
-                messages: [message, ack],
-            },
-        };
-        __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("container msg_id =", message.msg_id, "seqno =", message.seqno);
-    }
-    try {
-        const payload = await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_encryptMessage).call(this, message);
-        await this.transport.transport.send(payload);
-        pendingMessage.promiseWithResolvers.resolve(msg_id);
-    }
-    catch (err) {
-        pendingMessage.promiseWithResolvers.reject(err);
-        return;
-    }
-    __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").out(message);
-    __classPrivateFieldGet(this, _SessionEncrypted_sentMessages, "f").add(msg_id);
-    if (!(message.body instanceof Uint8Array)) {
-        const msg_ids = message.body.messages.map((v) => v.msg_id);
-        __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("sent container", message.msg_id, "with messages", ...msg_ids);
-        __classPrivateFieldGet(this, _SessionEncrypted_containers, "f").set(message.msg_id, msg_ids);
-    }
-    else {
-        __classPrivateFieldGet(this, _SessionEncrypted_LsendLoop, "f").debug("sent message", message.msg_id);
-    }
-}, _SessionEncrypted_receiveLoopBody = async function _SessionEncrypted_receiveLoopBody(loop) {
-    let message;
-    try {
-        __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").debug("receiving");
-        message = await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_receive).call(this);
-    }
-    catch (err) {
-        __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").error("failed to receive message:", err);
+    async #encryptMessage(message) {
+        const payloadWriter = new TLWriter();
+        payloadWriter.writeInt64(this.state.serverSalt);
+        payloadWriter.writeInt64(this.#id);
+        payloadWriter.write(await serializeMessage(message));
+        payloadWriter.write(new Uint8Array(mod(-(payloadWriter.buffer.length + 12), 16) + 12));
+        const payload = payloadWriter.buffer;
+        const messageKey = (await sha256(concat([this.#authKey.subarray(88, 120), payload]))).subarray(8, 24);
+        const a = await sha256(concat([messageKey, this.#authKey.subarray(0, 36)]));
+        const b = await sha256(concat([this.#authKey.subarray(40, 76), messageKey]));
+        const aesKey = concat([a.subarray(0, 8), b.subarray(8, 24), a.subarray(24, 32)]);
+        const aesIV = concat([b.subarray(0, 8), a.subarray(8, 24), b.subarray(24, 32)]);
+        const messageWriter = new TLWriter();
+        messageWriter.writeInt64(this.#authKeyId);
+        messageWriter.write(messageKey);
+        messageWriter.write(ige256Encrypt(payload, aesKey, aesIV));
+        return messageWriter.buffer;
+    }
+    async #decryptMessage(buffer) {
+        const reader = new TLReader(buffer);
+        assertEquals(reader.readInt64(), this.#authKeyId);
+        const messageKey_ = reader.readInt128();
+        const messageKey = intToBytes(messageKey_, 16);
+        const a = await sha256(concat([messageKey, this.#authKey.subarray(8, 44)]));
+        const b = await sha256(concat([this.#authKey.subarray(48, 84), messageKey]));
+        const aesKey = concat([a.subarray(0, 8), b.subarray(8, 24), a.subarray(24, 32)]);
+        const aesIv = concat([b.subarray(0, 8), a.subarray(8, 24), b.subarray(24, 32)]);
+        const plaintext = ige256Decrypt(reader.buffer, aesKey, aesIv);
+        assertEquals(plaintext.buffer.byteLength % 4, 0);
+        const plainReader = new TLReader(plaintext);
+        const _salt = plainReader.readInt64();
+        const _sessionId_ = plainReader.readInt64(false);
+        return deserializeMessage(plainReader);
+    }
+    //// SEND LOOP ////
+    #awakeSendLoop;
+    #sendLoop = new AbortableLoop(this.#sendLoopBody.bind(this), (err) => {
+        this.#LsendLoop.error("unhandled receive loop error:", err);
+    });
+    async #sendLoopBody(loop, signal) {
         if (!this.isConnected) {
-            __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").debug("aborting as not connected");
+            this.#LsendLoop.debug("aborting as not connected");
             loop.abort();
             return;
         }
-        else {
+        const pendingMessage = this.#pendingMessages.shift();
+        if (pendingMessage === undefined) {
+            this.#LsendLoop.debug("no pending messages");
+            return await new Promise((resolve) => {
+                const onAbort = () => {
+                    this.#LsendLoop.debug("got aborted while sleeping");
+                    resolve();
+                };
+                signal.addEventListener("abort", onAbort);
+                this.#awakeSendLoop = () => {
+                    this.#LsendLoop.debug("got awaken");
+                    resolve();
+                    signal.removeEventListener("abort", onAbort);
+                };
+            });
+        }
+        const msg_id = this.state.nextMessageId();
+        const seqno = this.state.nextSeqNo(true);
+        let message = {
+            _: "message",
+            msg_id,
+            seqno,
+            body: pendingMessage.body,
+        };
+        this.#LsendLoop.debug("msg_id =", msg_id, "seqno =", seqno);
+        if (this.#toAcknowledge.length) {
+            const msg_ids = this.#toAcknowledge.splice(0, 8192);
+            this.#LsendLoop.debug("acknowledging", msg_ids.length, "message(s) while sending this one");
+            const ack = {
+                _: "message",
+                msg_id: this.state.nextMessageId(),
+                seqno: this.state.nextSeqNo(false),
+                body: Mtproto.serializeObject({ _: "msgs_ack", msg_ids }),
+            };
+            this.#LsendLoop.debug("msgs_ack msg_id =", ack.msg_id, "seqno =", seqno);
+            this.#pendingAcks.set(ack.msg_id, msg_ids);
+            message = {
+                _: "message",
+                msg_id: this.state.nextMessageId(),
+                seqno: this.state.nextSeqNo(false),
+                body: {
+                    _: "msg_container",
+                    messages: [message, ack],
+                },
+            };
+            this.#LsendLoop.debug("container msg_id =", message.msg_id, "seqno =", message.seqno);
+        }
+        try {
+            const payload = await this.#encryptMessage(message);
+            await this.transport.transport.send(payload);
+            pendingMessage.promiseWithResolvers.resolve(msg_id);
+        }
+        catch (err) {
+            pendingMessage.promiseWithResolvers.reject(err);
             return;
         }
-    }
-    try {
-        if (message.body instanceof Uint8Array) {
-            await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMessage).call(this, message.msg_id, message.body, null);
+        this.#LsendLoop.out(message);
+        this.#sentMessages.add(msg_id);
+        if (!(message.body instanceof Uint8Array)) {
+            const msg_ids = message.body.messages.map((v) => v.msg_id);
+            this.#LsendLoop.debug("sent container", message.msg_id, "with messages", ...msg_ids);
+            this.#containers.set(message.msg_id, msg_ids);
         }
         else {
-            await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMessageContainer).call(this, message.msg_id, message.body);
+            this.#LsendLoop.debug("sent message", message.msg_id);
         }
     }
-    catch (err) {
-        __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").error("failed to handle message:", err);
-    }
-}, _SessionEncrypted_onMessage = 
-//// RECEIVE LOOP HANDLERS ////
-async function _SessionEncrypted_onMessage(msgId, body, containerId) {
-    __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").debug("received message with ID", msgId, "and size", body.length, "inside", ...(containerId === null ? ["no container"] : ["container", containerId]));
-    const logger = __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").branch(msgId + "");
-    let reader = new TLReader(body);
-    let id = reader.readInt32(false);
-    if (id === GZIP_PACKED) {
-        logger.debug("unpacking compressed body");
-        reader = new TLReader(await gunzip(reader.readBytes()));
-        id = reader.readInt32(false);
-    }
-    if (id === RPC_RESULT) {
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onRpcResult).call(this, msgId, reader.buffer, logger);
-        return;
-    }
-    if (!Mtproto.schema.identifierToName[id]) {
-        logger.debug("identified body as a non-MTProto constructor");
-        reader.unreadInt32();
-        this.handlers.onUpdate?.(reader.buffer);
-        return;
-    }
-    let type;
-    try {
-        reader.unreadInt32();
-        type = await Mtproto.deserializeType(X, reader);
-    }
-    catch (err) {
-        logger.error("failed to deserialize MTProto type:", err);
-        return;
-    }
-    logger.debug("received", repr(type));
-    if (Mtproto.is("new_session_created", type)) {
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onNewSessionCreated).call(this, msgId, type);
-    }
-    else if (Mtproto.is("pong", type)) {
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onPong).call(this, msgId, type);
-    }
-    else if (Mtproto.is("bad_server_salt", type)) {
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onBadServerSalt).call(this, type);
-    }
-    else if (Mtproto.is("bad_msg_notification", type)) {
-        await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onBadMsgNotification).call(this, msgId, type, logger);
-    }
-    else if (Mtproto.is("msg_detailed_info", type)) {
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMsgDetailedInfo).call(this, type, logger);
-    }
-    else if (Mtproto.is("msg_new_detailed_info", type)) {
-        __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMsgNewDetailedInfo).call(this, type, logger);
-    }
-    else {
-        logger.warning(`unhandled MTProto type: ${repr(type)}`);
-    }
-}, _SessionEncrypted_onRpcResult = async function _SessionEncrypted_onRpcResult(msgId, body, logger) {
-    logger.debug("received rpc_result");
-    __classPrivateFieldGet(this, _SessionEncrypted_toAcknowledge, "f").push(msgId);
-    let reader = new TLReader(body);
-    const reqMsgId = reader.readInt64();
-    let id = reader.readInt32(false);
-    if (id === GZIP_PACKED) {
-        logger.debug("unpacking compressed rpc_result");
-        reader = new TLReader(await gunzip(reader.readBytes()));
-        id = reader.readInt32(false);
-        reader.unreadInt32();
-    }
-    else {
-        reader.unreadInt32();
-    }
-    if (id === RPC_ERROR) {
-        logger.debug("received rpc_error from message", msgId);
-        const error = await Mtproto.deserializeType("rpc_error", reader);
-        this.handlers.onRpcError?.(reqMsgId, error);
-    }
-    else {
-        this.handlers.onRpcResult?.(reqMsgId, reader.buffer);
-    }
-}, _SessionEncrypted_onMsgDetailedInfo = function _SessionEncrypted_onMsgDetailedInfo(msgDetailedInfo, logger) {
-    logger.debug("scheduling the acknowledgement of", msgDetailedInfo.answer_msg_id, "because of", msgDetailedInfo._);
-    __classPrivateFieldGet(this, _SessionEncrypted_toAcknowledge, "f").push(msgDetailedInfo.answer_msg_id);
-}, _SessionEncrypted_onMsgNewDetailedInfo = function _SessionEncrypted_onMsgNewDetailedInfo(msgNewDetailedInfo, logger) {
-    logger.debug("scheduling the acknowledgement of", msgNewDetailedInfo.answer_msg_id, "because of", msgNewDetailedInfo._);
-    __classPrivateFieldGet(this, _SessionEncrypted_toAcknowledge, "f").push(msgNewDetailedInfo.answer_msg_id);
-}, _SessionEncrypted_onBadMsgNotification = async function _SessionEncrypted_onBadMsgNotification(msgId, badMsgNotification, logger) {
-    let low = false;
-    switch (badMsgNotification.error_code) {
-        case 16: // message ID too low
-            low = true;
-        /* falls through */
-        case 17: // message ID too high
-            this.state.timeDifference = Math.abs(toUnixTimestamp(new Date()) - Number(msgId >> 32n));
-            if (!low) {
-                this.state.timeDifference = -this.state.timeDifference;
-                logger.debug("resetting time difference to", -this.state.timeDifference, "because the ID of the message", badMsgNotification.bad_msg_id, "was too high");
-                await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_invalidateSession).call(this, "message ID too high");
+    //// RECEIVE LOOP ////
+    #receiveLoop = new AbortableLoop(this.#receiveLoopBody.bind(this), (err) => {
+        this.#LreceiveLoop.error("unhandled receive loop error:", err);
+    });
+    async #receiveLoopBody(loop) {
+        let message;
+        try {
+            this.#LreceiveLoop.debug("receiving");
+            message = await this.#receive();
+        }
+        catch (err) {
+            this.#LreceiveLoop.error("failed to receive message:", err);
+            if (!this.isConnected) {
+                this.#LreceiveLoop.debug("aborting as not connected");
+                loop.abort();
                 return;
             }
             else {
-                logger.debug("resending message", badMsgNotification.bad_msg_id, "because its ID was too low");
+                return;
             }
-            break;
-        case 48: // bad server salt
-            // resend
-            __classPrivateFieldGet(this, _SessionEncrypted_L, "f").debug("resending message that caused bad_server_salt");
-            break;
-        default:
-            await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_invalidateSession).call(this, "unexpected bad_msg_notification");
-            return;
-    }
-    __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMessageFailed).call(this, badMsgNotification.bad_msg_id, new SessionError(badMsgNotification._));
-}, _SessionEncrypted_onBadServerSalt = function _SessionEncrypted_onBadServerSalt(badServerSalt) {
-    __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_setServerSalt).call(this, badServerSalt.new_server_salt);
-    __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMessageFailed).call(this, badServerSalt.bad_msg_id, new SessionError(badServerSalt._));
-}, _SessionEncrypted_onPong = function _SessionEncrypted_onPong(msgId, pong) {
-    __classPrivateFieldGet(this, _SessionEncrypted_toAcknowledge, "f").push(msgId);
-    const pendingPing = __classPrivateFieldGet(this, _SessionEncrypted_pendingPings, "f").get(pong.msg_id);
-    if (pendingPing) {
-        pendingPing.promiseWithResolvers.resolve(pong);
-        __classPrivateFieldGet(this, _SessionEncrypted_pendingPings, "f").delete(pong.msg_id);
-    }
-    else {
-        // pong is not ours
-        this.handlers.onPong?.(pong);
+        }
+        try {
+            if (message.body instanceof Uint8Array) {
+                await this.#onMessage(message.msg_id, message.body, null);
+            }
+            else {
+                await this.#onMessageContainer(message.msg_id, message.body);
+            }
+        }
+        catch (err) {
+            this.#LreceiveLoop.error("failed to handle message:", err);
+        }
     }
-}, _SessionEncrypted_onNewSessionCreated = function _SessionEncrypted_onNewSessionCreated(msgId, newSessionCreated) {
-    __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_setServerSalt).call(this, newSessionCreated.server_salt);
-    __classPrivateFieldGet(this, _SessionEncrypted_toAcknowledge, "f").push(msgId);
-}, _SessionEncrypted_onMessageContainer = async function _SessionEncrypted_onMessageContainer(msgId, msgContainer) {
-    __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").debug("received container with ID", msgId, "and", msgContainer.messages.length, "message(s)");
-    for (const message of msgContainer.messages) {
-        if (message.body instanceof Uint8Array) {
-            await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMessage).call(this, message.msg_id, message.body, msgId);
+    //// RECEIVE LOOP HANDLERS ////
+    async #onMessage(msgId, body, containerId) {
+        this.#LreceiveLoop.debug("received message with ID", msgId, "and size", body.length, "inside", ...(containerId === null ? ["no container"] : ["container", containerId]));
+        const logger = this.#LreceiveLoop.branch(msgId + "");
+        let reader = new TLReader(body);
+        let id = reader.readInt32(false);
+        if (id === GZIP_PACKED) {
+            logger.debug("unpacking compressed body");
+            reader = new TLReader(await gunzip(reader.readBytes()));
+            id = reader.readInt32(false);
+        }
+        if (id === RPC_RESULT) {
+            this.#onRpcResult(msgId, reader.buffer, logger);
+            return;
+        }
+        if (!Mtproto.schema.identifierToName[id]) {
+            logger.debug("identified body as a non-MTProto constructor");
+            reader.unreadInt32();
+            this.handlers.onUpdate?.(reader.buffer);
+            return;
+        }
+        let type;
+        try {
+            reader.unreadInt32();
+            type = await Mtproto.deserializeType(X, reader);
+        }
+        catch (err) {
+            logger.error("failed to deserialize MTProto type:", err);
+            return;
+        }
+        logger.debug("received", repr(type));
+        if (Mtproto.is("new_session_created", type)) {
+            this.#onNewSessionCreated(msgId, type);
+        }
+        else if (Mtproto.is("pong", type)) {
+            this.#onPong(msgId, type);
+        }
+        else if (Mtproto.is("bad_server_salt", type)) {
+            this.#onBadServerSalt(type);
+        }
+        else if (Mtproto.is("bad_msg_notification", type)) {
+            await this.#onBadMsgNotification(msgId, type, logger);
+        }
+        else if (Mtproto.is("msg_detailed_info", type)) {
+            this.#onMsgDetailedInfo(type, logger);
+        }
+        else if (Mtproto.is("msg_new_detailed_info", type)) {
+            this.#onMsgNewDetailedInfo(type, logger);
         }
         else {
-            await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_onMessageContainer).call(this, msgId, message.body);
+            logger.warning(`unhandled MTProto type: ${repr(type)}`);
         }
     }
-}, _SessionEncrypted_pingLoopBody = async function _SessionEncrypted_pingLoopBody(_loop, signal) {
-    const ms = Math.max(0, __classPrivateFieldGet(this, _SessionEncrypted_pingInterval, "f") - __classPrivateFieldGet(this, _SessionEncrypted_timeElapsed, "f"));
-    if (ms) {
-        __classPrivateFieldGet(this, _SessionEncrypted_LpingLoop, "f").debug(`sending ping in ${ms}ms`);
-        await delay(ms, { signal });
-    }
-    else {
-        __classPrivateFieldGet(this, _SessionEncrypted_LpingLoop, "f").debug("sending ping now");
+    async #onRpcResult(msgId, body, logger) {
+        logger.debug("received rpc_result");
+        this.#toAcknowledge.push(msgId);
+        let reader = new TLReader(body);
+        const reqMsgId = reader.readInt64();
+        let id = reader.readInt32(false);
+        if (id === GZIP_PACKED) {
+            logger.debug("unpacking compressed rpc_result");
+            reader = new TLReader(await gunzip(reader.readBytes()));
+            id = reader.readInt32(false);
+            reader.unreadInt32();
+        }
+        else {
+            reader.unreadInt32();
+        }
+        if (id === RPC_ERROR) {
+            logger.debug("received rpc_error from message", msgId);
+            const error = await Mtproto.deserializeType("rpc_error", reader);
+            this.handlers.onRpcError?.(reqMsgId, error);
+        }
+        else {
+            this.handlers.onRpcResult?.(reqMsgId, reader.buffer);
+        }
     }
-    signal.throwIfAborted();
-    const then = Date.now();
-    try {
-        await __classPrivateFieldGet(this, _SessionEncrypted_instances, "m", _SessionEncrypted_sendPingDelayDisconnect).call(this, __classPrivateFieldGet(this, _SessionEncrypted_pingInterval, "f") / SECOND + 15);
-        __classPrivateFieldGet(this, _SessionEncrypted_LpingLoop, "f").debug("received pong");
+    #onMsgDetailedInfo(msgDetailedInfo, logger) {
+        logger.debug("scheduling the acknowledgement of", msgDetailedInfo.answer_msg_id, "because of", msgDetailedInfo._);
+        this.#toAcknowledge.push(msgDetailedInfo.answer_msg_id);
+    }
+    #onMsgNewDetailedInfo(msgNewDetailedInfo, logger) {
+        logger.debug("scheduling the acknowledgement of", msgNewDetailedInfo.answer_msg_id, "because of", msgNewDetailedInfo._);
+        this.#toAcknowledge.push(msgNewDetailedInfo.answer_msg_id);
+    }
+    async #onBadMsgNotification(msgId, badMsgNotification, logger) {
+        let low = false;
+        switch (badMsgNotification.error_code) {
+            case 16: // message ID too low
+                low = true;
+            /* falls through */
+            case 17: // message ID too high
+                this.state.timeDifference = Math.abs(toUnixTimestamp(new Date()) - Number(msgId >> 32n));
+                if (!low) {
+                    this.state.timeDifference = -this.state.timeDifference;
+                    logger.debug("resetting time difference to", -this.state.timeDifference, "because the ID of the message", badMsgNotification.bad_msg_id, "was too high");
+                    await this.#invalidateSession("message ID too high");
+                    return;
+                }
+                else {
+                    logger.debug("resending message", badMsgNotification.bad_msg_id, "because its ID was too low");
+                }
+                break;
+            case 48: // bad server salt
+                // resend
+                this.#L.debug("resending message that caused bad_server_salt");
+                break;
+            default:
+                await this.#invalidateSession("unexpected bad_msg_notification");
+                return;
+        }
+        this.#onMessageFailed(badMsgNotification.bad_msg_id, new SessionError(badMsgNotification._));
+    }
+    #onBadServerSalt(badServerSalt) {
+        this.#setServerSalt(badServerSalt.new_server_salt);
+        this.#onMessageFailed(badServerSalt.bad_msg_id, new SessionError(badServerSalt._));
+    }
+    #onPong(msgId, pong) {
+        this.#toAcknowledge.push(msgId);
+        const pendingPing = this.#pendingPings.get(pong.msg_id);
+        if (pendingPing) {
+            pendingPing.promiseWithResolvers.resolve(pong);
+            this.#pendingPings.delete(pong.msg_id);
+        }
+        else {
+            // pong is not ours
+            this.handlers.onPong?.(pong);
+        }
     }
-    finally {
-        __classPrivateFieldSet(this, _SessionEncrypted_timeElapsed, Date.now() - then, "f");
-        __classPrivateFieldGet(this, _SessionEncrypted_LpingLoop, "f").debug(`took ${__classPrivateFieldGet(this, _SessionEncrypted_timeElapsed, "f")}`);
+    #onNewSessionCreated(msgId, newSessionCreated) {
+        this.#setServerSalt(newSessionCreated.server_salt);
+        this.#toAcknowledge.push(msgId);
     }
-    signal.throwIfAborted();
-}, _SessionEncrypted_sendPingDelayDisconnect = async function _SessionEncrypted_sendPingDelayDisconnect(disconnect_delay) {
-    const ping_id = getRandomId();
-    const call = { _: "ping_delay_disconnect", ping_id, disconnect_delay };
-    const messageId = await this.send(Mtproto.serializeObject(call));
-    const promiseWithResolvers = Promise.withResolvers();
-    __classPrivateFieldGet(this, _SessionEncrypted_pendingPings, "f").set(messageId, { call, promiseWithResolvers });
-    await promiseWithResolvers.promise;
-}, _SessionEncrypted_resendPendingPing = async function _SessionEncrypted_resendPendingPing(pendingPing) {
-    try {
-        const messageId = await this.send(Mtproto.serializeObject(pendingPing.call));
-        __classPrivateFieldGet(this, _SessionEncrypted_pendingPings, "f").set(messageId, pendingPing);
-        __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").debug("ping resent");
+    async #onMessageContainer(msgId, msgContainer) {
+        this.#LreceiveLoop.debug("received container with ID", msgId, "and", msgContainer.messages.length, "message(s)");
+        for (const message of msgContainer.messages) {
+            if (message.body instanceof Uint8Array) {
+                await this.#onMessage(message.msg_id, message.body, msgId);
+            }
+            else {
+                await this.#onMessageContainer(msgId, message.body);
+            }
+        }
     }
-    catch (err) {
-        __classPrivateFieldGet(this, _SessionEncrypted_LreceiveLoop, "f").debug("rejecting ping because of failed resend:", err);
-        pendingPing.promiseWithResolvers.reject(err);
+    //// PING LOOP ////
+    #pingInterval = 56 * SECOND;
+    #pingLoop = new AbortableLoop(this.#pingLoopBody.bind(this), (_, err) => {
+        this.#LpingLoop.error(err);
+    });
+    #timeElapsed = 0;
+    async #pingLoopBody(_loop, signal) {
+        const ms = Math.max(0, this.#pingInterval - this.#timeElapsed);
+        if (ms) {
+            this.#LpingLoop.debug(`sending ping in ${ms}ms`);
+            await delay(ms, { signal });
+        }
+        else {
+            this.#LpingLoop.debug("sending ping now");
+        }
+        signal.throwIfAborted();
+        const then = Date.now();
+        try {
+            await this.#sendPingDelayDisconnect(this.#pingInterval / SECOND + 15);
+            this.#LpingLoop.debug("received pong");
+        }
+        finally {
+            this.#timeElapsed = Date.now() - then;
+            this.#LpingLoop.debug(`took ${this.#timeElapsed}`);
+        }
+        signal.throwIfAborted();
+    }
+    async #sendPingDelayDisconnect(disconnect_delay) {
+        const ping_id = getRandomId();
+        const call = { _: "ping_delay_disconnect", ping_id, disconnect_delay };
+        const messageId = await this.send(Mtproto.serializeObject(call));
+        const promiseWithResolvers = Promise.withResolvers();
+        this.#pendingPings.set(messageId, { call, promiseWithResolvers });
+        await promiseWithResolvers.promise;
+    }
+    async #resendPendingPing(pendingPing) {
+        try {
+            const messageId = await this.send(Mtproto.serializeObject(pendingPing.call));
+            this.#pendingPings.set(messageId, pendingPing);
+            this.#LreceiveLoop.debug("ping resent");
+        }
+        catch (err) {
+            this.#LreceiveLoop.debug("rejecting ping because of failed resend:", err);
+            pendingPing.promiseWithResolvers.reject(err);
+        }
     }
-};
-_SessionEncrypted_TGCRYPTO_INITED = { value: false };
+}