@mtkruto/node 0.67.1 → 0.68.0

package/esm/deps/jsr.io/@std/datetime/0.225.5/_date_time_formatter.js

@@ -1,17 +1,5 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 // This module is browser compatible.
-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 _DateTimeFormatter_formatParts;
 function digits(value, count = 2) {
     return String(value).padStart(count, "0");
 }
@@ -134,14 +122,14 @@ function sortDateTimeFormatParts(parts) {
     return result;
 }
 export class DateTimeFormatter {
+    #formatParts;
     constructor(formatString) {
-        _DateTimeFormatter_formatParts.set(this, void 0);
-        __classPrivateFieldSet(this, _DateTimeFormatter_formatParts, formatToFormatParts(formatString), "f");
+        this.#formatParts = formatToFormatParts(formatString);
     }
     format(date, options = {}) {
         let string = "";
         const utc = options.timeZone === "UTC";
-        for (const part of __classPrivateFieldGet(this, _DateTimeFormatter_formatParts, "f")) {
+        for (const part of this.#formatParts) {
             const type = part.type;
             switch (type) {
                 case "year": {
@@ -274,7 +262,7 @@ export class DateTimeFormatter {
     }
     formatToParts(string) {
         const parts = [];
-        for (const part of __classPrivateFieldGet(this, _DateTimeFormatter_formatParts, "f")) {
+        for (const part of this.#formatParts) {
             const type = part.type;
             let length = 0;
             let value = "";
@@ -547,4 +535,3 @@ export class DateTimeFormatter {
         return this.partsToDate(parts);
     }
 }
-_DateTimeFormatter_formatParts = new WeakMap();

package/esm/deps/jsr.io/@std/internal/1.0.10/build_message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_message.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/build_message.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ;AAClB;;;GAGG;AACH,UAAU,UAAQ,GACjB,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CASvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CASrD;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,OAAO,GAAE,mBAAwB,GAChC,MAAM,EAAE,CAsBV"}

package/esm/deps/jsr.io/@std/internal/1.0.10/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/diff.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;CACZ;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAanD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAWvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,CAAC,EAAE,EACN,CAAC,EAAE,CAAC,EAAE,EACN,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,GACzB,KAAK,CAAC;IACP,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAgCD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,aAAa,GACnB,aAAa,CAsBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAwEvD"}

package/esm/deps/jsr.io/@std/internal/1.0.10/diff_str.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff_str.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/diff_str.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAY/C;AAKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,MAAM,EAAE,CAiBnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,EACxB,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,GAC3B,UAAU,CAAC,MAAM,CAAC,EAAE,CAetB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,EAAE,CAkDlE"}

package/esm/deps/jsr.io/@std/internal/1.0.10/format.d.ts

@@ -0,0 +1,29 @@
+export type InspectFn = (v: unknown, options: {
+    depth: number;
+    sorted: boolean;
+    trailingComma: boolean;
+    compact: boolean;
+    iterableLimit: number;
+    getters: boolean;
+    strAbbreviateSize: number;
+}) => string;
+/**
+ * Converts the input into a string. Objects, Sets and Maps are sorted so as to
+ * make tests less flaky.
+ *
+ * @param v Value to be formatted
+ *
+ * @returns The formatted string
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/internal/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(format({ a: 1, b: 2 }), "{\n  a: 1,\n  b: 2,\n}");
+ * assertEquals(format(new Set([1, 2])), "Set(2) {\n  1,\n  2,\n}");
+ * assertEquals(format(new Map([[1, 2]])), "Map(1) {\n  1 => 2,\n}");
+ * ```
+ */
+export declare function format(v: unknown): string;
+//# sourceMappingURL=format.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.10/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/format.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,SAAS,GAAG,CACtB,CAAC,EAAE,OAAO,EACV,OAAO,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,KACE,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAmBzC"}

package/esm/deps/jsr.io/@std/internal/1.0.10/format.js

@@ -0,0 +1,70 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/** An inspect function conforming to the shape of `Deno.inspect` and `node:util`'s `inspect` */
+import * as dntShim from "../../../../../_dnt.shims.js";
+/**
+ * Converts the input into a string. Objects, Sets and Maps are sorted so as to
+ * make tests less flaky.
+ *
+ * @param v Value to be formatted
+ *
+ * @returns The formatted string
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/internal/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(format({ a: 1, b: 2 }), "{\n  a: 1,\n  b: 2,\n}");
+ * assertEquals(format(new Set([1, 2])), "Set(2) {\n  1,\n  2,\n}");
+ * assertEquals(format(new Map([[1, 2]])), "Map(1) {\n  1 => 2,\n}");
+ * ```
+ */
+export function format(v) {
+    // deno-lint-ignore no-explicit-any
+    const { Deno, process } = dntShim.dntGlobalThis;
+    const inspect = Deno?.inspect ??
+        process?.getBuiltinModule?.("node:util")?.inspect;
+    return typeof inspect === "function"
+        ? inspect(v, {
+            depth: Infinity,
+            sorted: true,
+            trailingComma: true,
+            compact: false,
+            iterableLimit: Infinity,
+            // getters should be true in assertEquals.
+            getters: true,
+            strAbbreviateSize: Infinity,
+        })
+        : basicInspect(v);
+}
+const formatters = [
+    (v) => {
+        if (typeof v === "undefined")
+            return "undefined";
+        if (typeof v === "bigint")
+            return `${v}n`;
+        if (typeof v === "string" ||
+            typeof v === "number" ||
+            typeof v === "boolean" ||
+            v === null ||
+            Array.isArray(v) ||
+            [null, Object.prototype].includes(Object.getPrototypeOf(v))) {
+            return JSON.stringify(v, null, 2);
+        }
+    },
+    (v) => String(v),
+    (v) => Object.prototype.toString.call(v),
+];
+// for environments lacking both `Deno.inspect` and `process.inspect`
+function basicInspect(v) {
+    for (const fmt of formatters) {
+        try {
+            const result = fmt(v);
+            if (typeof result === "string")
+                return result;
+        }
+        catch { /* try the next one */ }
+    }
+    return "[[Unable to format value]]";
+}

package/esm/deps/jsr.io/@std/internal/1.0.10/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/styles.ts"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAWD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/esm/deps/jsr.io/@std/internal/1.0.10/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/types.ts"],"names":[],"mappings":"AAGA,kDAAkD;AAClD,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEtD;;;;GAIG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,4BAA4B;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,6BAA6B;IAC7B,KAAK,EAAE,CAAC,CAAC;IACT,+BAA+B;IAC/B,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;CAC3B"}

package/esm/mod.js

@@ -35,19 +35,9 @@ if (!("CompressionStream" in dntShim.dntGlobalThis)) {
     // original idea: MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource>
     // @see https://github.com/oven-sh/bun/issues/1723#issuecomment-1774174194
     class Stream {
+        readable;
+        writable;
         constructor(compress, format) {
-            Object.defineProperty(this, "readable", {
-                enumerable: true,
-                configurable: true,
-                writable: true,
-                value: void 0
-            });
-            Object.defineProperty(this, "writable", {
-                enumerable: true,
-                configurable: true,
-                writable: true,
-                value: void 0
-            });
             let handler;
             if (format === "gzip") {
                 handler = compress ? createGzip() : createGunzip();

package/esm/session/0_session_state.js

@@ -17,61 +17,35 @@
  * 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 __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 __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 _SessionState_seqNo, _SessionState_messageId;
 import { toUnixTimestamp } from "../1_utilities.js";
 export class SessionState {
-    constructor() {
-        Object.defineProperty(this, "timeDifference", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "serverSalt", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0n
-        });
-        _SessionState_seqNo.set(this, 0);
-        _SessionState_messageId.set(this, 0n);
-    }
+    timeDifference = 0;
+    serverSalt = 0n;
+    #seqNo = 0;
+    #messageId = 0n;
     nextMessageId() {
         const now = toUnixTimestamp(new Date()) + this.timeDifference;
         const nanoseconds = Math.floor((now - Math.floor(now)) * 1e9);
         const newMessageId = (BigInt(Math.floor(now)) << 32n) || (BigInt(nanoseconds) << 2n);
-        if (__classPrivateFieldGet(this, _SessionState_messageId, "f") >= newMessageId) {
-            __classPrivateFieldSet(this, _SessionState_messageId, __classPrivateFieldGet(this, _SessionState_messageId, "f") + 4n, "f");
+        if (this.#messageId >= newMessageId) {
+            this.#messageId += 4n;
         }
         else {
-            __classPrivateFieldSet(this, _SessionState_messageId, newMessageId, "f");
+            this.#messageId = newMessageId;
         }
-        return __classPrivateFieldGet(this, _SessionState_messageId, "f");
+        return this.#messageId;
     }
     nextSeqNo(contentRelated) {
-        var _a;
-        let seqNo = __classPrivateFieldGet(this, _SessionState_seqNo, "f") * 2;
+        let seqNo = this.#seqNo * 2;
         if (contentRelated) {
             seqNo++;
-            __classPrivateFieldSet(this, _SessionState_seqNo, (_a = __classPrivateFieldGet(this, _SessionState_seqNo, "f"), _a++, _a), "f");
+            this.#seqNo++;
         }
         return seqNo;
     }
     reset() {
         this.serverSalt = 0n;
-        __classPrivateFieldSet(this, _SessionState_seqNo, 0, "f");
-        __classPrivateFieldSet(this, _SessionState_messageId, 0n, "f");
+        this.#seqNo = 0;
+        this.#messageId = 0n;
     }
 }
-_SessionState_seqNo = new WeakMap(), _SessionState_messageId = new WeakMap();

package/esm/session/1_session.js

@@ -1,15 +1,3 @@
-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 _Session_instances, _Session_dc, _Session_cdn, _Session_lastConnect, _Session_disconnected, _Session_L, _Session_onConnectionStateChange, _Session_lastState, _Session_stateChangeHandler, _Session_connectMutex;
 /**
  * MTKruto - Cross-runtime JavaScript library for building Telegram clients
  * Copyright (C) 2023-2025 Roj <https://roj.im/>
@@ -39,107 +27,96 @@ let id = 0;
 // @ts-ignore: lib
 const defaultTransportProvider = typeof dntShim.Deno === "undefined" ? transportProviderWebSocket : transportProviderTcp;
 export class Session {
+    #dc;
+    #cdn;
+    state = new SessionState();
+    transport;
+    #lastConnect;
+    #disconnected = true;
+    #L;
+    #onConnectionStateChange;
     constructor(dc, params) {
-        _Session_instances.add(this);
-        _Session_dc.set(this, void 0);
-        _Session_cdn.set(this, void 0);
-        Object.defineProperty(this, "state", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new SessionState()
-        });
-        Object.defineProperty(this, "transport", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        _Session_lastConnect.set(this, void 0);
-        _Session_disconnected.set(this, true);
-        _Session_L.set(this, void 0);
-        _Session_onConnectionStateChange.set(this, void 0);
-        _Session_lastState.set(this, void 0);
-        _Session_connectMutex.set(this, new Mutex());
-        __classPrivateFieldSet(this, _Session_dc, dc, "f");
-        __classPrivateFieldSet(this, _Session_cdn, params?.cdn ?? false, "f");
+        this.#dc = dc;
+        this.#cdn = params?.cdn ?? false;
         const transportProvider = params?.transportProvider ?? defaultTransportProvider();
-        this.transport = transportProvider({ dc: __classPrivateFieldGet(this, _Session_dc, "f"), cdn: __classPrivateFieldGet(this, _Session_cdn, "f") });
+        this.transport = transportProvider({ dc: this.#dc, cdn: this.#cdn });
         this.transport.connection.stateChangeHandler = (connected) => {
             setTimeout(() => {
-                drop(__classPrivateFieldGet(this, _Session_instances, "m", _Session_stateChangeHandler).call(this, connected));
+                drop(this.#stateChangeHandler(connected));
             });
         };
-        __classPrivateFieldSet(this, _Session_L, getLogger("Session").client(id++), "f");
+        this.#L = getLogger("Session").client(id++);
     }
     set onConnectionStateChange(onConnectionStateChange) {
-        __classPrivateFieldSet(this, _Session_onConnectionStateChange, onConnectionStateChange, "f");
+        this.#onConnectionStateChange = onConnectionStateChange;
     }
     set connectionCallback(connectionCallback) {
         this.transport.connection.callback = connectionCallback;
     }
     get dc() {
-        return __classPrivateFieldGet(this, _Session_dc, "f");
+        return this.#dc;
     }
     get cdn() {
-        return __classPrivateFieldGet(this, _Session_cdn, "f");
+        return this.#cdn;
     }
     set serverSalt(serverSalt) {
         this.state.serverSalt = serverSalt;
     }
+    #lastState;
+    async #stateChangeHandler(connected) {
+        if (this.#lastState !== connected) {
+            setTimeout(() => {
+                this.#onConnectionStateChange?.(connected);
+            });
+        }
+        if (this.#lastState === connected) {
+            return;
+        }
+        this.#lastState = connected;
+        if (connected || this.#disconnected) {
+            if (this.#disconnected) {
+                this.#L.debug("not reconnecting because explicitly disconnected");
+            }
+            return;
+        }
+        if (this.#lastConnect && Date.now() - this.#lastConnect.getTime() <= 10 * SECOND) {
+            this.#L.debug("reconnecting after a delay");
+            await delay(3 * SECOND);
+        }
+        else {
+            this.#L.debug("reconnecting");
+        }
+        await this.connect();
+    }
     get connected() {
         return this.transport.connection.connected;
     }
+    #connectMutex = new Mutex();
     async connect() {
-        const unlock = await __classPrivateFieldGet(this, _Session_connectMutex, "f").lock();
+        const unlock = await this.#connectMutex.lock();
         try {
             if (this.connected) {
                 return;
             }
             await this.transport.connection.open();
             await this.transport.transport.initialize();
-            __classPrivateFieldSet(this, _Session_lastConnect, new Date(), "f");
-            __classPrivateFieldSet(this, _Session_disconnected, false, "f");
+            this.#lastConnect = new Date();
+            this.#disconnected = false;
         }
         finally {
             unlock();
         }
     }
     async waitUntilConnected() {
-        (await __classPrivateFieldGet(this, _Session_connectMutex, "f").lock())();
+        (await this.#connectMutex.lock())();
     }
     get disconnected() {
-        return __classPrivateFieldGet(this, _Session_disconnected, "f");
+        return this.#disconnected;
     }
     disconnect() {
-        __classPrivateFieldSet(this, _Session_disconnected, true, "f");
+        this.#disconnected = true;
         if (this.transport.connection.connected) {
             this.transport.connection.close();
         }
     }
 }
-_Session_dc = new WeakMap(), _Session_cdn = new WeakMap(), _Session_lastConnect = new WeakMap(), _Session_disconnected = new WeakMap(), _Session_L = new WeakMap(), _Session_onConnectionStateChange = new WeakMap(), _Session_lastState = new WeakMap(), _Session_connectMutex = new WeakMap(), _Session_instances = new WeakSet(), _Session_stateChangeHandler = async function _Session_stateChangeHandler(connected) {
-    if (__classPrivateFieldGet(this, _Session_lastState, "f") !== connected) {
-        setTimeout(() => {
-            __classPrivateFieldGet(this, _Session_onConnectionStateChange, "f")?.call(this, connected);
-        });
-    }
-    if (__classPrivateFieldGet(this, _Session_lastState, "f") === connected) {
-        return;
-    }
-    __classPrivateFieldSet(this, _Session_lastState, connected, "f");
-    if (connected || __classPrivateFieldGet(this, _Session_disconnected, "f")) {
-        if (__classPrivateFieldGet(this, _Session_disconnected, "f")) {
-            __classPrivateFieldGet(this, _Session_L, "f").debug("not reconnecting because explicitly disconnected");
-        }
-        return;
-    }
-    if (__classPrivateFieldGet(this, _Session_lastConnect, "f") && Date.now() - __classPrivateFieldGet(this, _Session_lastConnect, "f").getTime() <= 10 * SECOND) {
-        __classPrivateFieldGet(this, _Session_L, "f").debug("reconnecting after a delay");
-        await delay(3 * SECOND);
-    }
-    else {
-        __classPrivateFieldGet(this, _Session_L, "f").debug("reconnecting");
-    }
-    await this.connect();
-};