@mtkruto/browser 0.119.0 → 0.119.1

package/esm/client/2_bot_info_manager.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 _BotInfoManager_instances, _BotInfoManager_c, _BotInfoManager_setMyInfo, _BotInfoManager_getMyInfo;
 import { Api } from "../2_tl.js";
 import { botCommandScopeToTlObject } from "../3_types.js";
 import { peerToChatId } from "../tl/2_telegram.js";
@@ -36,54 +24,59 @@ const botInfoManagerUpdates = [
     "updateBotCommands",
 ];
 export class BotInfoManager {
+    #c;
     constructor(c) {
-        _BotInfoManager_instances.add(this);
-        _BotInfoManager_c.set(this, void 0);
-        __classPrivateFieldSet(this, _BotInfoManager_c, c, "f");
+        this.#c = c;
     }
     canHandleUpdate(update) {
         return Api.isOneOf(botInfoManagerUpdates, update);
     }
+    async #setMyInfo(info) {
+        await this.#c.invoke({ _: "bots.setBotInfo", ...info });
+    }
     async setMyDescription(params) {
-        __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("setMyDescription");
-        await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_setMyInfo).call(this, { description: params?.description, lang_code: params?.languageCode ?? "" });
+        this.#c.storage.assertBot("setMyDescription");
+        await this.#setMyInfo({ description: params?.description, lang_code: params?.languageCode ?? "" });
     }
     async setMyName(params) {
-        __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("setMyName");
-        await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_setMyInfo).call(this, { name: params?.name, lang_code: params?.languageCode ?? "" });
+        this.#c.storage.assertBot("setMyName");
+        await this.#setMyInfo({ name: params?.name, lang_code: params?.languageCode ?? "" });
     }
     async setMyShortDescription(params) {
-        __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("setMyShortDescription");
-        await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_setMyInfo).call(this, { about: params?.shortDescription, lang_code: params?.languageCode ?? "" });
+        this.#c.storage.assertBot("setMyShortDescription");
+        await this.#setMyInfo({ about: params?.shortDescription, lang_code: params?.languageCode ?? "" });
+    }
+    #getMyInfo(languageCode) {
+        return this.#c.invoke({ _: "bots.getBotInfo", lang_code: languageCode ?? "" });
     }
     async getMyDescription(params) {
-        __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("getMyDescription");
-        return (await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_getMyInfo).call(this, params?.languageCode)).description;
+        this.#c.storage.assertBot("getMyDescription");
+        return (await this.#getMyInfo(params?.languageCode)).description;
     }
     async getMyName(params) {
-        __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("getMyName");
-        return (await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_getMyInfo).call(this, params?.languageCode)).description;
+        this.#c.storage.assertBot("getMyName");
+        return (await this.#getMyInfo(params?.languageCode)).description;
     }
     async getMyShortDescription(params) {
-        __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("getMyShortDescription");
-        return (await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_getMyInfo).call(this, params?.languageCode)).about;
+        this.#c.storage.assertBot("getMyShortDescription");
+        return (await this.#getMyInfo(params?.languageCode)).about;
     }
     async getMyCommands(params) {
-        __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("getMyCommands");
-        const commands_ = await __classPrivateFieldGet(this, _BotInfoManager_c, "f").invoke({
+        this.#c.storage.assertBot("getMyCommands");
+        const commands_ = await this.#c.invoke({
             _: "bots.getBotCommands",
             lang_code: params?.languageCode ?? "",
-            scope: await botCommandScopeToTlObject(params?.scope ?? { type: "default" }, __classPrivateFieldGet(this, _BotInfoManager_c, "f").getInputPeer),
+            scope: await botCommandScopeToTlObject(params?.scope ?? { type: "default" }, this.#c.getInputPeer),
         });
         return commands_.map((v) => ({ command: v.command, description: v.description }));
     }
     async setMyCommands(commands, params) {
-        __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("setMyCommands");
-        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").invoke({
+        this.#c.storage.assertBot("setMyCommands");
+        await this.#c.invoke({
             _: "bots.setBotCommands",
             commands: commands.map((v) => ({ ...v, _: "botCommand" })),
             lang_code: params?.languageCode ?? "",
-            scope: await botCommandScopeToTlObject(params?.scope ?? { type: "default" }, __classPrivateFieldGet(this, _BotInfoManager_c, "f").getInputPeer),
+            scope: await botCommandScopeToTlObject(params?.scope ?? { type: "default" }, this.#c.getInputPeer),
         });
     }
     handleUpdate(update) {
@@ -93,8 +86,3 @@ export class BotInfoManager {
         return { botCommands: { botId, chatId, commands } };
     }
 }
-_BotInfoManager_c = new WeakMap(), _BotInfoManager_instances = new WeakSet(), _BotInfoManager_setMyInfo = async function _BotInfoManager_setMyInfo(info) {
-    await __classPrivateFieldGet(this, _BotInfoManager_c, "f").invoke({ _: "bots.setBotInfo", ...info });
-}, _BotInfoManager_getMyInfo = function _BotInfoManager_getMyInfo(languageCode) {
-    return __classPrivateFieldGet(this, _BotInfoManager_c, "f").invoke({ _: "bots.getBotInfo", lang_code: languageCode ?? "" });
-};

package/esm/client/2_business_connection_manager.js

@@ -17,39 +17,27 @@
  * 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 _BusinessConnectionManager_c;
 import { Api } from "../2_tl.js";
 import { constructBusinessConnection } from "../3_types.js";
 const businessConnectionManagerUpdates = [
     "updateBotBusinessConnect",
 ];
 export class BusinessConnectionManager {
+    #c;
     constructor(c) {
-        _BusinessConnectionManager_c.set(this, void 0);
-        __classPrivateFieldSet(this, _BusinessConnectionManager_c, c, "f");
+        this.#c = c;
     }
     async getBusinessConnection(id) {
-        const connection_ = await __classPrivateFieldGet(this, _BusinessConnectionManager_c, "f").messageStorage.getBusinessConnection(id);
+        const connection_ = await this.#c.messageStorage.getBusinessConnection(id);
         if (!connection_) {
-            const connection_ = await __classPrivateFieldGet(this, _BusinessConnectionManager_c, "f").invoke({ _: "account.getBotBusinessConnection", connection_id: id })
+            const connection_ = await this.#c.invoke({ _: "account.getBotBusinessConnection", connection_id: id })
                 .then((v) => Api.as("updates", v))
                 .then((v) => Api.as("updateBotBusinessConnect", v.updates[0]).connection);
-            await __classPrivateFieldGet(this, _BusinessConnectionManager_c, "f").messageStorage.setBusinessConnection(id, connection_);
-            return constructBusinessConnection(connection_, __classPrivateFieldGet(this, _BusinessConnectionManager_c, "f").getPeer);
+            await this.#c.messageStorage.setBusinessConnection(id, connection_);
+            return constructBusinessConnection(connection_, this.#c.getPeer);
         }
         else {
-            return constructBusinessConnection(connection_, __classPrivateFieldGet(this, _BusinessConnectionManager_c, "f").getPeer);
+            return constructBusinessConnection(connection_, this.#c.getPeer);
         }
     }
     canHandleUpdate(update) {
@@ -57,13 +45,12 @@ export class BusinessConnectionManager {
     }
     async handleUpdate(update) {
         if (update.connection.disabled) {
-            await __classPrivateFieldGet(this, _BusinessConnectionManager_c, "f").messageStorage.setBusinessConnection(update.connection.connection_id, null);
+            await this.#c.messageStorage.setBusinessConnection(update.connection.connection_id, null);
         }
         else {
-            await __classPrivateFieldGet(this, _BusinessConnectionManager_c, "f").messageStorage.setBusinessConnection(update.connection.connection_id, update.connection);
+            await this.#c.messageStorage.setBusinessConnection(update.connection.connection_id, update.connection);
         }
-        const businessConnection = constructBusinessConnection(update.connection, __classPrivateFieldGet(this, _BusinessConnectionManager_c, "f").getPeer);
+        const businessConnection = constructBusinessConnection(update.connection, this.#c.getPeer);
         return { businessConnection };
     }
 }
-_BusinessConnectionManager_c = new WeakMap();

package/esm/client/2_client_encrypted.js

@@ -17,18 +17,7 @@
  * 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 _ClientEncrypted_instances, _a, _ClientEncrypted_SEND_MAX_TRIES, _ClientEncrypted_AUTH_KEY_CREATION_MAX_TRIES, _ClientEncrypted_L, _ClientEncrypted_plain, _ClientEncrypted_sentRequests, _ClientEncrypted_apiId, _ClientEncrypted_appVersion, _ClientEncrypted_deviceModel, _ClientEncrypted_langCode, _ClientEncrypted_langPack, _ClientEncrypted_systemLangCode, _ClientEncrypted_systemVersion, _ClientEncrypted_disableUpdates, _ClientEncrypted_createAuthKeyPromise, _ClientEncrypted_createAuthKey, _ClientEncrypted_createAuthKeyInner, _ClientEncrypted_connectionInited, _ClientEncrypted_send, _ClientEncrypted_resend, _ClientEncrypted_onUpdate, _ClientEncrypted_onNewServerSalt, _ClientEncrypted_onMessageFailed, _ClientEncrypted_onRpcError, _ClientEncrypted_onRpcResult, _ClientEncrypted_onPong;
+var _a;
 import { InputError } from "../0_errors.js";
 import { getLogger } from "../1_utilities.js";
 import { Api, Mtproto, X } from "../2_tl.js";
@@ -42,61 +31,44 @@ import { ClientPlain } from "./1_client_plain.js";
 // global ClientEncrypted ID counter for logs
 let id = 0;
 export class ClientEncrypted extends ClientAbstract {
+    static #SEND_MAX_TRIES = 10;
+    static #AUTH_KEY_CREATION_MAX_TRIES = 10;
+    handlers = {};
+    #L;
+    #plain;
+    session;
+    #sentRequests = new Map();
+    #apiId;
+    #appVersion;
+    #deviceModel;
+    #langCode;
+    #langPack;
+    #systemLangCode;
+    #systemVersion;
+    #disableUpdates;
     constructor(dc, apiId, params) {
         super();
-        _ClientEncrypted_instances.add(this);
-        Object.defineProperty(this, "handlers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        _ClientEncrypted_L.set(this, void 0);
-        _ClientEncrypted_plain.set(this, void 0);
-        Object.defineProperty(this, "session", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        _ClientEncrypted_sentRequests.set(this, new Map());
-        _ClientEncrypted_apiId.set(this, void 0);
-        _ClientEncrypted_appVersion.set(this, void 0);
-        _ClientEncrypted_deviceModel.set(this, void 0);
-        _ClientEncrypted_langCode.set(this, void 0);
-        _ClientEncrypted_langPack.set(this, void 0);
-        _ClientEncrypted_systemLangCode.set(this, void 0);
-        _ClientEncrypted_systemVersion.set(this, void 0);
-        _ClientEncrypted_disableUpdates.set(this, void 0);
-        _ClientEncrypted_createAuthKeyPromise.set(this, void 0);
-        _ClientEncrypted_connectionInited.set(this, false);
-        Object.defineProperty(this, "lastRequest", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        __classPrivateFieldSet(this, _ClientEncrypted_L, getLogger("ClientEncrypted").client(id++), "f");
-        __classPrivateFieldSet(this, _ClientEncrypted_plain, new ClientPlain(dc, params), "f");
+        this.#L = getLogger("ClientEncrypted").client(id++);
+        this.#plain = new ClientPlain(dc, params);
         this.session = new SessionEncrypted(dc, params);
-        this.session.handlers.onUpdate = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_onUpdate).bind(this);
-        this.session.handlers.onNewServerSalt = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_onNewServerSalt).bind(this);
-        this.session.handlers.onMessageFailed = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_onMessageFailed).bind(this);
-        this.session.handlers.onRpcError = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_onRpcError).bind(this);
-        this.session.handlers.onRpcResult = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_onRpcResult).bind(this);
-        this.session.handlers.onPong = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_onPong).bind(this);
-        __classPrivateFieldSet(this, _ClientEncrypted_apiId, apiId, "f");
-        __classPrivateFieldSet(this, _ClientEncrypted_appVersion, params?.appVersion ?? APP_VERSION, "f");
-        __classPrivateFieldSet(this, _ClientEncrypted_deviceModel, params?.deviceModel ?? DEVICE_MODEL, "f");
-        __classPrivateFieldSet(this, _ClientEncrypted_langCode, params?.langCode ?? LANG_CODE, "f");
-        __classPrivateFieldSet(this, _ClientEncrypted_langPack, params?.langPack ?? LANG_PACK, "f");
-        __classPrivateFieldSet(this, _ClientEncrypted_systemLangCode, params?.systemLangCode ?? SYSTEM_LANG_CODE, "f");
-        __classPrivateFieldSet(this, _ClientEncrypted_systemVersion, params?.systemVersion ?? SYSTEM_VERSION, "f");
-        __classPrivateFieldSet(this, _ClientEncrypted_disableUpdates, params?.disableUpdates ?? false, "f");
+        this.session.handlers.onUpdate = this.#onUpdate.bind(this);
+        this.session.handlers.onNewServerSalt = this.#onNewServerSalt.bind(this);
+        this.session.handlers.onMessageFailed = this.#onMessageFailed.bind(this);
+        this.session.handlers.onRpcError = this.#onRpcError.bind(this);
+        this.session.handlers.onRpcResult = this.#onRpcResult.bind(this);
+        this.session.handlers.onPong = this.#onPong.bind(this);
+        this.#apiId = apiId;
+        this.#appVersion = params?.appVersion ?? APP_VERSION;
+        this.#deviceModel = params?.deviceModel ?? DEVICE_MODEL;
+        this.#langCode = params?.langCode ?? LANG_CODE;
+        this.#langPack = params?.langPack ?? LANG_PACK;
+        this.#systemLangCode = params?.systemLangCode ?? SYSTEM_LANG_CODE;
+        this.#systemVersion = params?.systemVersion ?? SYSTEM_VERSION;
+        this.#disableUpdates = params?.disableUpdates ?? false;
     }
     async connect() {
         if (!this.authKey.length) {
-            await __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_createAuthKey).call(this);
+            await this.#createAuthKey();
         }
         await super.connect();
     }
@@ -104,187 +76,198 @@ export class ClientEncrypted extends ClientAbstract {
         super.disconnect();
         this.lastRequest = undefined;
     }
-    get authKey() {
-        return this.session.authKey;
-    }
-    async setAuthKey(authKey) {
-        await this.session.setAuthKey(authKey);
-    }
-    async invoke(function_) {
-        const messageId = await __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_send).call(this, function_);
-        __classPrivateFieldGet(this, _ClientEncrypted_L, "f").debug("sent", function_._, "with msg_id", messageId);
-        const sentRequest = { call: function_, promiseWithResolvers: Promise.withResolvers() };
-        __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").set(messageId, sentRequest);
-        return await sentRequest.promiseWithResolvers.promise;
+    #createAuthKeyPromise;
+    #createAuthKey() {
+        return this.#createAuthKeyPromise ??= this.#createAuthKeyInner().finally(() => {
+            this.#createAuthKeyPromise = undefined;
+        });
     }
-}
-_a = ClientEncrypted, _ClientEncrypted_L = new WeakMap(), _ClientEncrypted_plain = new WeakMap(), _ClientEncrypted_sentRequests = new WeakMap(), _ClientEncrypted_apiId = new WeakMap(), _ClientEncrypted_appVersion = new WeakMap(), _ClientEncrypted_deviceModel = new WeakMap(), _ClientEncrypted_langCode = new WeakMap(), _ClientEncrypted_langPack = new WeakMap(), _ClientEncrypted_systemLangCode = new WeakMap(), _ClientEncrypted_systemVersion = new WeakMap(), _ClientEncrypted_disableUpdates = new WeakMap(), _ClientEncrypted_createAuthKeyPromise = new WeakMap(), _ClientEncrypted_connectionInited = new WeakMap(), _ClientEncrypted_instances = new WeakSet(), _ClientEncrypted_createAuthKey = function _ClientEncrypted_createAuthKey() {
-    return __classPrivateFieldSet(this, _ClientEncrypted_createAuthKeyPromise, __classPrivateFieldGet(this, _ClientEncrypted_createAuthKeyPromise, "f") ?? __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_createAuthKeyInner).call(this).finally(() => {
-        __classPrivateFieldSet(this, _ClientEncrypted_createAuthKeyPromise, undefined, "f");
-    }), "f");
-}, _ClientEncrypted_createAuthKeyInner = async function _ClientEncrypted_createAuthKeyInner() {
-    let lastErr;
-    let errored = false;
-    for (let i = 0; i < __classPrivateFieldGet(_a, _a, "f", _ClientEncrypted_AUTH_KEY_CREATION_MAX_TRIES); ++i) {
-        try {
-            await __classPrivateFieldGet(this, _ClientEncrypted_plain, "f").connect();
-            const [authKey, serverSalt] = await __classPrivateFieldGet(this, _ClientEncrypted_plain, "f").createAuthKey();
-            await this.setAuthKey(authKey);
-            this.serverSalt = serverSalt;
-            errored = false;
-            break;
-        }
-        catch (err) {
-            errored = true;
-            lastErr = err;
-            if (this.isDisconnected) {
+    async #createAuthKeyInner() {
+        let lastErr;
+        let errored = false;
+        for (let i = 0; i < _a.#AUTH_KEY_CREATION_MAX_TRIES; ++i) {
+            try {
+                await this.#plain.connect();
+                const [authKey, serverSalt] = await this.#plain.createAuthKey();
+                await this.setAuthKey(authKey);
+                this.serverSalt = serverSalt;
+                errored = false;
                 break;
             }
-            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").error("failed to create auth key:", err);
+            catch (err) {
+                errored = true;
+                lastErr = err;
+                if (this.isDisconnected) {
+                    break;
+                }
+                this.#L.error("failed to create auth key:", err);
+            }
+            finally {
+                this.#plain.disconnect();
+            }
         }
-        finally {
-            __classPrivateFieldGet(this, _ClientEncrypted_plain, "f").disconnect();
+        if (errored) {
+            throw lastErr;
         }
     }
-    if (errored) {
-        throw lastErr;
+    get authKey() {
+        return this.session.authKey;
     }
-}, _ClientEncrypted_send = async function _ClientEncrypted_send(function_) {
-    this.lastRequest = new Date();
-    let body;
-    if (Mtproto.is("ping", function_)) {
-        body = Mtproto.serializeObject(function_);
+    async setAuthKey(authKey) {
+        await this.session.setAuthKey(authKey);
     }
-    else {
-        if (__classPrivateFieldGet(this, _ClientEncrypted_disableUpdates, "f") && !isCdnFunction(function_)) {
-            function_ = { _: "invokeWithoutUpdates", query: function_ };
+    #connectionInited = false;
+    lastRequest;
+    async #send(function_) {
+        this.lastRequest = new Date();
+        let body;
+        if (Mtproto.is("ping", function_)) {
+            body = Mtproto.serializeObject(function_);
         }
-        if (!__classPrivateFieldGet(this, _ClientEncrypted_connectionInited, "f")) {
-            if (!__classPrivateFieldGet(this, _ClientEncrypted_apiId, "f")) {
-                throw new InputError("apiId not set");
+        else {
+            if (this.#disableUpdates && !isCdnFunction(function_)) {
+                function_ = { _: "invokeWithoutUpdates", query: function_ };
             }
-            function_ = {
-                _: "initConnection",
-                api_id: __classPrivateFieldGet(this, _ClientEncrypted_apiId, "f"),
-                app_version: __classPrivateFieldGet(this, _ClientEncrypted_appVersion, "f"),
-                device_model: __classPrivateFieldGet(this, _ClientEncrypted_deviceModel, "f"),
-                lang_code: __classPrivateFieldGet(this, _ClientEncrypted_langCode, "f"),
-                lang_pack: __classPrivateFieldGet(this, _ClientEncrypted_langPack, "f"),
-                query: {
-                    _: "invokeWithLayer",
-                    layer: Api.LAYER,
-                    query: function_,
-                },
-                system_lang_code: __classPrivateFieldGet(this, _ClientEncrypted_systemLangCode, "f"),
-                system_version: __classPrivateFieldGet(this, _ClientEncrypted_systemVersion, "f"),
-            };
-        }
-        body = Api.serializeObject(function_);
-    }
-    let lastErr;
-    for (let i = 0; i < __classPrivateFieldGet(_a, _a, "f", _ClientEncrypted_SEND_MAX_TRIES); ++i) {
-        let errored = false;
-        try {
-            return await this.session.send(body);
-        }
-        catch (err) {
-            errored = true;
-            lastErr = err;
-            if (this.isDisconnected) {
-                break;
+            if (!this.#connectionInited) {
+                if (!this.#apiId) {
+                    throw new InputError("apiId not set");
+                }
+                function_ = {
+                    _: "initConnection",
+                    api_id: this.#apiId,
+                    app_version: this.#appVersion,
+                    device_model: this.#deviceModel,
+                    lang_code: this.#langCode,
+                    lang_pack: this.#langPack,
+                    query: {
+                        _: "invokeWithLayer",
+                        layer: Api.LAYER,
+                        query: function_,
+                    },
+                    system_lang_code: this.#systemLangCode,
+                    system_version: this.#systemVersion,
+                };
             }
-            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").error("send failed:", err);
+            body = Api.serializeObject(function_);
         }
-        finally {
-            if (!errored) {
-                __classPrivateFieldGet(this, _ClientEncrypted_L, "f").debug("invoked", repr(function_));
-                __classPrivateFieldGet(this, _ClientEncrypted_L, "f").out(function_);
+        let lastErr;
+        for (let i = 0; i < _a.#SEND_MAX_TRIES; ++i) {
+            let errored = false;
+            try {
+                return await this.session.send(body);
+            }
+            catch (err) {
+                errored = true;
+                lastErr = err;
+                if (this.isDisconnected) {
+                    break;
+                }
+                this.#L.error("send failed:", err);
+            }
+            finally {
+                if (!errored) {
+                    this.#L.debug("invoked", repr(function_));
+                    this.#L.out(function_);
+                }
             }
         }
+        throw new Error(`Failed to invoke function after ${_a.#SEND_MAX_TRIES} tries.`, { cause: lastErr });
     }
-    throw new Error(`Failed to invoke function after ${__classPrivateFieldGet(_a, _a, "f", _ClientEncrypted_SEND_MAX_TRIES)} tries.`, { cause: lastErr });
-}, _ClientEncrypted_resend = async function _ClientEncrypted_resend(request) {
-    try {
-        const messageId = await __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_send).call(this, request.call);
-        __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").set(messageId, request);
-    }
-    catch (err) {
-        __classPrivateFieldGet(this, _ClientEncrypted_L, "f").error("rejecting message because of resend error:", err);
-        request.promiseWithResolvers.reject(err);
-    }
-}, _ClientEncrypted_onUpdate = async function _ClientEncrypted_onUpdate(body) {
-    let type;
-    try {
-        type = await Api.deserializeType(X, body);
-    }
-    catch (err) {
-        __classPrivateFieldGet(this, _ClientEncrypted_L, "f").error("failed to deserialize update:", err);
-        this.handlers.onDeserializationError?.();
-        return;
-    }
-    if (Api.isOfEnum("Update", type) || Api.isOfEnum("Updates", type)) {
-        this.handlers.onUpdate?.(type);
-    }
-    else {
-        __classPrivateFieldGet(this, _ClientEncrypted_L, "f").warning("received unknown type:", repr(type));
-    }
-}, _ClientEncrypted_onNewServerSalt = function _ClientEncrypted_onNewServerSalt(serverSalt) {
-    this.handlers.onNewServerSalt?.(serverSalt);
-}, _ClientEncrypted_onMessageFailed = async function _ClientEncrypted_onMessageFailed(msgId, error) {
-    const request = __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").get(msgId);
-    if (request) {
-        __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").delete(msgId);
-        if (error instanceof SessionError) {
-            await __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_resend).call(this, request);
+    async #resend(request) {
+        try {
+            const messageId = await this.#send(request.call);
+            this.#sentRequests.set(messageId, request);
         }
-        else {
-            request.promiseWithResolvers.reject(error);
+        catch (err) {
+            this.#L.error("rejecting message because of resend error:", err);
+            request.promiseWithResolvers.reject(err);
         }
     }
-}, _ClientEncrypted_onRpcError = async function _ClientEncrypted_onRpcError(msgId, error) {
-    const request = __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").get(msgId);
-    __classPrivateFieldGet(this, _ClientEncrypted_L, "f").debug("received rpc_error with req_msg_id =", msgId, "for", request === undefined ? "unknown" : "known", "request");
-    if (request) {
-        __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").delete(msgId);
-        const reason = constructTelegramError(error, request.call);
-        if (reason instanceof ConnectionNotInited) {
-            __classPrivateFieldSet(this, _ClientEncrypted_connectionInited, false, "f");
-            await __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_resend).call(this, request);
-        }
-        else {
-            request.promiseWithResolvers.reject(constructTelegramError(error, request.call));
-        }
+    async invoke(function_) {
+        const messageId = await this.#send(function_);
+        this.#L.debug("sent", function_._, "with msg_id", messageId);
+        const sentRequest = { call: function_, promiseWithResolvers: Promise.withResolvers() };
+        this.#sentRequests.set(messageId, sentRequest);
+        return await sentRequest.promiseWithResolvers.promise;
     }
-}, _ClientEncrypted_onRpcResult = async function _ClientEncrypted_onRpcResult(msgId, body) {
-    const sentRequest = __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").get(msgId);
-    __classPrivateFieldGet(this, _ClientEncrypted_L, "f").debug("received rpc_result with req_msg_id =", msgId, "for", sentRequest === undefined ? "unknown" : "known", "request");
-    if (sentRequest) {
+    async #onUpdate(body) {
         let type;
         try {
-            type = await Api.deserializeType(Api.mustGetReturnType(sentRequest.call._), body);
-            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").in(type);
-            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").debug("received rpc_result", repr(type));
-            sentRequest.promiseWithResolvers.resolve(type);
+            type = await Api.deserializeType(X, body);
         }
         catch (err) {
-            sentRequest.promiseWithResolvers.reject(err);
-            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").error("failed to deserialize rpc_result body:", err);
+            this.#L.error("failed to deserialize update:", err);
             this.handlers.onDeserializationError?.();
             return;
         }
-        finally {
-            __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").delete(msgId);
+        if (Api.isOfEnum("Update", type) || Api.isOfEnum("Updates", type)) {
+            this.handlers.onUpdate?.(type);
+        }
+        else {
+            this.#L.warning("received unknown type:", repr(type));
         }
     }
-    if (!__classPrivateFieldGet(this, _ClientEncrypted_connectionInited, "f")) {
-        __classPrivateFieldSet(this, _ClientEncrypted_connectionInited, true, "f");
+    #onNewServerSalt(serverSalt) {
+        this.handlers.onNewServerSalt?.(serverSalt);
     }
-}, _ClientEncrypted_onPong = function _ClientEncrypted_onPong(pong) {
-    const sentRequest = __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").get(pong.msg_id);
-    if (sentRequest) {
-        sentRequest.promiseWithResolvers.resolve(pong);
-        __classPrivateFieldGet(this, _ClientEncrypted_sentRequests, "f").delete(pong.msg_id);
+    async #onMessageFailed(msgId, error) {
+        const request = this.#sentRequests.get(msgId);
+        if (request) {
+            this.#sentRequests.delete(msgId);
+            if (error instanceof SessionError) {
+                await this.#resend(request);
+            }
+            else {
+                request.promiseWithResolvers.reject(error);
+            }
+        }
+    }
+    async #onRpcError(msgId, error) {
+        const request = this.#sentRequests.get(msgId);
+        this.#L.debug("received rpc_error with req_msg_id =", msgId, "for", request === undefined ? "unknown" : "known", "request");
+        if (request) {
+            this.#sentRequests.delete(msgId);
+            const reason = constructTelegramError(error, request.call);
+            if (reason instanceof ConnectionNotInited) {
+                this.#connectionInited = false;
+                await this.#resend(request);
+            }
+            else {
+                request.promiseWithResolvers.reject(constructTelegramError(error, request.call));
+            }
+        }
+    }
+    async #onRpcResult(msgId, body) {
+        const sentRequest = this.#sentRequests.get(msgId);
+        this.#L.debug("received rpc_result with req_msg_id =", msgId, "for", sentRequest === undefined ? "unknown" : "known", "request");
+        if (sentRequest) {
+            let type;
+            try {
+                type = await Api.deserializeType(Api.mustGetReturnType(sentRequest.call._), body);
+                this.#L.in(type);
+                this.#L.debug("received rpc_result", repr(type));
+                sentRequest.promiseWithResolvers.resolve(type);
+            }
+            catch (err) {
+                sentRequest.promiseWithResolvers.reject(err);
+                this.#L.error("failed to deserialize rpc_result body:", err);
+                this.handlers.onDeserializationError?.();
+                return;
+            }
+            finally {
+                this.#sentRequests.delete(msgId);
+            }
+        }
+        if (!this.#connectionInited) {
+            this.#connectionInited = true;
+        }
+    }
+    #onPong(pong) {
+        const sentRequest = this.#sentRequests.get(pong.msg_id);
+        if (sentRequest) {
+            sentRequest.promiseWithResolvers.resolve(pong);
+            this.#sentRequests.delete(pong.msg_id);
+        }
     }
-};
-_ClientEncrypted_SEND_MAX_TRIES = { value: 10 };
-_ClientEncrypted_AUTH_KEY_CREATION_MAX_TRIES = { value: 10 };
+}
+_a = ClientEncrypted;