@mtkruto/node 0.67.2 → 0.69.0

package/esm/connection/0_connection.d.ts

@@ -17,7 +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/>.
  */
-import { MaybePromise } from "../1_utilities.js";
+import type { MaybePromise } from "../1_utilities.js";
 export interface ConnectionCallback {
     read(count: number): void;
     write(count: number): void;

package/esm/connection/0_connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"0_connection.d.ts","sourceRoot":"","sources":["../../src/connection/0_connection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,SAAS,IAAI,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,IAAI,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAC3B,KAAK,CAAC,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,KAAK,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;CACzC"}
+{"version":3,"file":"0_connection.d.ts","sourceRoot":"","sources":["../../src/connection/0_connection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,SAAS,IAAI,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,IAAI,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAC3B,KAAK,CAAC,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,KAAK,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;CACzC"}

package/esm/connection/1_connection_tcp.node.d.ts

@@ -17,7 +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/>.
  */
-import { Connection } from "./0_connection.js";
+import type { Connection } from "./0_connection.js";
 export declare class ConnectionTCP implements Connection {
     #private;
     stateChangeHandler?: Connection["stateChangeHandler"];

package/esm/connection/1_connection_tcp.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_connection_tcp.node.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tcp.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAK/C,qBAAa,aAAc,YAAW,UAAU;;IAW9C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAY1C,IAAI;IAuCJ,IAAI,SAAS,YAEZ;IAQK,IAAI,CAAC,CAAC,EAAE,UAAU;IAclB,KAAK,CAAC,CAAC,EAAE,UAAU;IA0BzB,KAAK;CAKN"}
+{"version":3,"file":"1_connection_tcp.node.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tcp.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAKpD,qBAAa,aAAc,YAAW,UAAU;;IAW9C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAY1C,IAAI;IAuCJ,IAAI,SAAS,YAEZ;IAQK,IAAI,CAAC,CAAC,EAAE,UAAU;IAclB,KAAK,CAAC,CAAC,EAAE,UAAU;IA0BzB,KAAK;CAKN"}

package/esm/connection/1_connection_tcp.node.js

@@ -17,98 +17,91 @@
  * 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 _ConnectionTCP_instances, _ConnectionTCP_hostname, _ConnectionTCP_port, _ConnectionTCP_socket, _ConnectionTCP_rMutex, _ConnectionTCP_wMutex, _ConnectionTCP_buffer, _ConnectionTCP_nextResolve, _ConnectionTCP_rejectRead, _ConnectionTCP_assertConnected;
 import { Socket } from "node:net";
 import { ConnectionError } from "../0_errors.js";
 import { getLogger, Mutex } from "../1_utilities.js";
 const L = getLogger("ConnectionTCP");
 const errConnectionNotOpen = new ConnectionError("Connection not open");
 export class ConnectionTCP {
+    #hostname;
+    #port;
+    #socket;
+    #rMutex = new Mutex();
+    #wMutex = new Mutex();
+    #buffer = new Array();
+    #nextResolve = null;
+    stateChangeHandler;
     constructor(hostname, port) {
-        _ConnectionTCP_instances.add(this);
-        _ConnectionTCP_hostname.set(this, void 0);
-        _ConnectionTCP_port.set(this, void 0);
-        _ConnectionTCP_socket.set(this, void 0);
-        _ConnectionTCP_rMutex.set(this, new Mutex());
-        _ConnectionTCP_wMutex.set(this, new Mutex());
-        _ConnectionTCP_buffer.set(this, new Array());
-        _ConnectionTCP_nextResolve.set(this, null);
-        Object.defineProperty(this, "stateChangeHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        __classPrivateFieldSet(this, _ConnectionTCP_hostname, hostname, "f");
-        __classPrivateFieldSet(this, _ConnectionTCP_port, port, "f");
+        this.#hostname = hostname;
+        this.#port = port;
+    }
+    #rejectRead() {
+        if (this.#nextResolve !== null) {
+            this.#nextResolve[1].reject(errConnectionNotOpen);
+            this.#nextResolve = null;
+        }
     }
     open() {
-        __classPrivateFieldSet(this, _ConnectionTCP_socket, new Socket(), "f");
-        __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").on("close", () => {
-            __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_rejectRead).call(this);
+        this.#socket = new Socket();
+        this.#socket.on("close", () => {
+            this.#rejectRead();
             this.stateChangeHandler?.(false);
         });
         const mutex = new Mutex();
-        __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").on("data", async (data) => {
+        this.#socket.on("data", async (data) => {
             const unlock = await mutex.lock();
             for (const byte of data) {
-                __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").push(byte);
+                this.#buffer.push(byte);
             }
-            if (__classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f") != null && __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").length >= __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[0]) {
-                const resolve = __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[1].resolve;
-                __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, null, "f");
+            if (this.#nextResolve !== null && this.#buffer.length >= this.#nextResolve[0]) {
+                const resolve = this.#nextResolve[1].resolve;
+                this.#nextResolve = null;
                 resolve();
             }
             unlock();
         });
         return new Promise((resolve, reject) => {
-            __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").connect(__classPrivateFieldGet(this, _ConnectionTCP_port, "f"), __classPrivateFieldGet(this, _ConnectionTCP_hostname, "f"));
-            __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").once("error", reject);
-            __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").once("connect", () => {
-                __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").off("error", reject);
+            this.#socket.connect(this.#port, this.#hostname);
+            this.#socket.once("error", reject);
+            this.#socket.once("connect", () => {
+                this.#socket.off("error", reject);
                 resolve();
                 this.stateChangeHandler?.(true);
-                L.debug("connected to", __classPrivateFieldGet(this, _ConnectionTCP_hostname, "f"), "port", __classPrivateFieldGet(this, _ConnectionTCP_port, "f"));
+                L.debug("connected to", this.#hostname, "port", this.#port);
             });
         });
     }
     get connected() {
-        return __classPrivateFieldGet(this, _ConnectionTCP_socket, "f")?.readyState == "open";
+        return this.#socket?.readyState === "open";
+    }
+    #assertConnected() {
+        if (!this.connected) {
+            throw errConnectionNotOpen;
+        }
     }
     async read(p) {
-        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
-        const unlock = await __classPrivateFieldGet(this, _ConnectionTCP_rMutex, "f").lock();
+        this.#assertConnected();
+        const unlock = await this.#rMutex.lock();
         try {
-            __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
-            if (__classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").length < p.length) {
-                await new Promise((resolve, reject) => __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, [p.length, { resolve, reject }], "f"));
+            this.#assertConnected();
+            if (this.#buffer.length < p.length) {
+                await new Promise((resolve, reject) => this.#nextResolve = [p.length, { resolve, reject }]);
             }
-            p.set(__classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").splice(0, p.length));
+            p.set(this.#buffer.splice(0, p.length));
         }
         finally {
             unlock();
         }
     }
     async write(p) {
-        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
-        const unlock = await __classPrivateFieldGet(this, _ConnectionTCP_wMutex, "f").lock();
+        this.#assertConnected();
+        const unlock = await this.#wMutex.lock();
         try {
-            __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+            this.#assertConnected();
             try {
                 await new Promise((resolve, reject) => {
-                    __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").write(p, (err) => {
-                        (err === undefined || err == null) ? resolve() : reject(err);
+                    this.#socket.write(p, (err) => {
+                        (err === undefined || err === null) ? resolve() : reject(err);
                     });
                 });
             }
@@ -126,18 +119,8 @@ export class ConnectionTCP {
         }
     }
     close() {
-        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
-        __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").destroy();
-        __classPrivateFieldSet(this, _ConnectionTCP_socket, undefined, "f");
+        this.#assertConnected();
+        this.#socket.destroy();
+        this.#socket = undefined;
     }
 }
-_ConnectionTCP_hostname = new WeakMap(), _ConnectionTCP_port = new WeakMap(), _ConnectionTCP_socket = new WeakMap(), _ConnectionTCP_rMutex = new WeakMap(), _ConnectionTCP_wMutex = new WeakMap(), _ConnectionTCP_buffer = new WeakMap(), _ConnectionTCP_nextResolve = new WeakMap(), _ConnectionTCP_instances = new WeakSet(), _ConnectionTCP_rejectRead = function _ConnectionTCP_rejectRead() {
-    if (__classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f") != null) {
-        __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[1].reject(errConnectionNotOpen);
-        __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, null, "f");
-    }
-}, _ConnectionTCP_assertConnected = function _ConnectionTCP_assertConnected() {
-    if (!this.connected) {
-        throw errConnectionNotOpen;
-    }
-};

package/esm/connection/1_connection_web_socket.d.ts

@@ -1,4 +1,4 @@
-import { Connection } from "./0_connection.js";
+import type { Connection } from "./0_connection.js";
 export declare class ConnectionWebSocket implements Connection {
     #private;
     stateChangeHandler?: Connection["stateChangeHandler"];

package/esm/connection/1_connection_web_socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_connection_web_socket.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_web_socket.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAK/C,qBAAa,mBAAoB,YAAW,UAAU;;IAOpD,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,GAAG,EAAE,MAAM;IA8CvB,IAAI,SAAS,IAAI,OAAO,CAEvB;IAGK,IAAI;IAuBJ,IAAI,CAAC,CAAC,EAAE,UAAU;IAgBlB,KAAK,CAAC,CAAC,EAAE,UAAU;IAkBzB,KAAK;CAMN"}
+{"version":3,"file":"1_connection_web_socket.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_web_socket.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAKpD,qBAAa,mBAAoB,YAAW,UAAU;;IAOpD,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,GAAG,EAAE,MAAM;IA8CvB,IAAI,SAAS,IAAI,OAAO,CAEvB;IAGK,IAAI;IAuBJ,IAAI,CAAC,CAAC,EAAE,UAAU;IAgBlB,KAAK,CAAC,CAAC,EAAE,UAAU;IAkBzB,KAAK;CAMN"}

package/esm/connection/1_connection_web_socket.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 _ConnectionWebSocket_instances, _ConnectionWebSocket_url, _ConnectionWebSocket_webSocket, _ConnectionWebSocket_rMutex, _ConnectionWebSocket_wMutex, _ConnectionWebSocket_buffer, _ConnectionWebSocket_nextResolve, _ConnectionWebSocket_initWs, _ConnectionWebSocket_isConnecting, _ConnectionWebSocket_assertConnected, _ConnectionWebSocket_rejectRead;
 /**
  * MTKruto - Cross-runtime JavaScript library for building Telegram clients
  * Copyright (C) 2023-2025 Roj <https://roj.im/>
@@ -36,117 +24,113 @@ import { getLogger, Mutex } from "../1_utilities.js";
 const L = getLogger("ConnectionWebSocket");
 const errConnectionNotOpen = new ConnectionError("Connection not open");
 export class ConnectionWebSocket {
+    #url;
+    #webSocket;
+    #rMutex = new Mutex();
+    #wMutex = new Mutex();
+    #buffer = new Uint8Array();
+    #nextResolve = null;
+    stateChangeHandler;
     constructor(url) {
-        _ConnectionWebSocket_instances.add(this);
-        _ConnectionWebSocket_url.set(this, void 0);
-        _ConnectionWebSocket_webSocket.set(this, void 0);
-        _ConnectionWebSocket_rMutex.set(this, new Mutex());
-        _ConnectionWebSocket_wMutex.set(this, new Mutex());
-        _ConnectionWebSocket_buffer.set(this, new Uint8Array());
-        _ConnectionWebSocket_nextResolve.set(this, null);
-        Object.defineProperty(this, "stateChangeHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
+        this.#url = url;
+    }
+    #initWs() {
+        return new Promise((resolve, reject) => {
+            const webSocket = new dntShim.WebSocket(this.#url, "binary");
+            const mutex = new Mutex();
+            webSocket.addEventListener("close", () => {
+                this.#rejectRead();
+                this.stateChangeHandler?.(false);
+            });
+            webSocket.addEventListener("open", () => {
+                this.stateChangeHandler?.(true);
+                resolve(webSocket);
+                L.debug("connected to", this.#url);
+            });
+            webSocket.addEventListener("message", async (e) => {
+                if (typeof e.data === "string") {
+                    return;
+                }
+                const unlock = await mutex.lock();
+                const data = new Uint8Array(await new Blob([e.data].map((v) => v instanceof Blob || v instanceof Uint8Array ? v : v instanceof ArrayBuffer ? v : unreachable())).arrayBuffer());
+                this.#buffer = concat([this.#buffer, data]);
+                if (this.#nextResolve !== null && this.#buffer.length >= this.#nextResolve[0]) {
+                    this.#nextResolve[1].resolve();
+                    this.#nextResolve = null;
+                }
+                unlock();
+            });
+            webSocket.addEventListener("error", (err) => {
+                if (this.#isConnecting) {
+                    reject("message" in err ? new ConnectionError(err.message) : new ConnectionError("Connection failed"));
+                }
+                if (this.connected) {
+                    L.error(err);
+                }
+            });
         });
-        _ConnectionWebSocket_isConnecting.set(this, false);
-        __classPrivateFieldSet(this, _ConnectionWebSocket_url, url, "f");
     }
     get connected() {
-        return !!__classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f") && __classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").readyState == dntShim.WebSocket.OPEN;
+        return !!this.#webSocket && this.#webSocket.readyState === dntShim.WebSocket.OPEN;
     }
+    #isConnecting = false;
     async open() {
-        if (__classPrivateFieldGet(this, _ConnectionWebSocket_isConnecting, "f")) {
+        if (this.#isConnecting) {
             throw new ConnectionError("Already connecting");
         }
-        __classPrivateFieldSet(this, _ConnectionWebSocket_isConnecting, true, "f");
+        this.#isConnecting = true;
         if (this.connected) {
             throw new ConnectionError("Already connected");
         }
         try {
-            __classPrivateFieldSet(this, _ConnectionWebSocket_webSocket, await __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_initWs).call(this), "f");
+            this.#webSocket = await this.#initWs();
         }
         finally {
-            __classPrivateFieldSet(this, _ConnectionWebSocket_isConnecting, false, "f");
+            this.#isConnecting = false;
+        }
+    }
+    #assertConnected() {
+        if (!this.connected) {
+            throw errConnectionNotOpen;
         }
     }
     async read(p) {
-        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
-        const unlock = await __classPrivateFieldGet(this, _ConnectionWebSocket_rMutex, "f").lock();
+        this.#assertConnected();
+        const unlock = await this.#rMutex.lock();
         try {
-            __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
-            if (__classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f").length < p.length) {
-                await new Promise((resolve, reject) => __classPrivateFieldSet(this, _ConnectionWebSocket_nextResolve, [p.length, { resolve, reject }], "f"));
+            this.#assertConnected();
+            if (this.#buffer.length < p.length) {
+                await new Promise((resolve, reject) => this.#nextResolve = [p.length, { resolve, reject }]);
             }
-            const slice = __classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f").slice(0, p.length);
+            const slice = this.#buffer.slice(0, p.length);
             p.set(slice);
-            __classPrivateFieldSet(this, _ConnectionWebSocket_buffer, __classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f").slice(slice.length), "f");
+            this.#buffer = this.#buffer.slice(slice.length);
         }
         finally {
             unlock();
         }
     }
     async write(p) {
-        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
-        const unlock = await __classPrivateFieldGet(this, _ConnectionWebSocket_wMutex, "f").lock();
+        this.#assertConnected();
+        const unlock = await this.#wMutex.lock();
         try {
-            __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
-            __classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").send(p);
+            this.#assertConnected();
+            this.#webSocket.send(p);
         }
         finally {
             unlock();
         }
     }
+    #rejectRead() {
+        if (this.#nextResolve !== null) {
+            this.#nextResolve[1].reject(errConnectionNotOpen);
+            this.#nextResolve = null;
+        }
+    }
     close() {
-        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
-        __classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").close(1000, "method");
-        __classPrivateFieldSet(this, _ConnectionWebSocket_webSocket, undefined, "f");
-        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_rejectRead).call(this);
+        this.#assertConnected();
+        this.#webSocket.close(1000, "method");
+        this.#webSocket = undefined;
+        this.#rejectRead();
     }
 }
-_ConnectionWebSocket_url = new WeakMap(), _ConnectionWebSocket_webSocket = new WeakMap(), _ConnectionWebSocket_rMutex = new WeakMap(), _ConnectionWebSocket_wMutex = new WeakMap(), _ConnectionWebSocket_buffer = new WeakMap(), _ConnectionWebSocket_nextResolve = new WeakMap(), _ConnectionWebSocket_isConnecting = new WeakMap(), _ConnectionWebSocket_instances = new WeakSet(), _ConnectionWebSocket_initWs = function _ConnectionWebSocket_initWs() {
-    return new Promise((resolve, reject) => {
-        const webSocket = new dntShim.WebSocket(__classPrivateFieldGet(this, _ConnectionWebSocket_url, "f"), "binary");
-        const mutex = new Mutex();
-        webSocket.addEventListener("close", () => {
-            __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_rejectRead).call(this);
-            this.stateChangeHandler?.(false);
-        });
-        webSocket.addEventListener("open", () => {
-            this.stateChangeHandler?.(true);
-            resolve(webSocket);
-            L.debug("connected to", __classPrivateFieldGet(this, _ConnectionWebSocket_url, "f"));
-        });
-        webSocket.addEventListener("message", async (e) => {
-            if (typeof e.data === "string") {
-                return;
-            }
-            const unlock = await mutex.lock();
-            const data = new Uint8Array(await new Blob([e.data].map((v) => v instanceof Blob || v instanceof Uint8Array ? v : v instanceof ArrayBuffer ? v : unreachable())).arrayBuffer());
-            __classPrivateFieldSet(this, _ConnectionWebSocket_buffer, concat([__classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f"), data]), "f");
-            if (__classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f") != null && __classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f").length >= __classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f")[0]) {
-                __classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f")[1].resolve();
-                __classPrivateFieldSet(this, _ConnectionWebSocket_nextResolve, null, "f");
-            }
-            unlock();
-        });
-        webSocket.addEventListener("error", (err) => {
-            if (__classPrivateFieldGet(this, _ConnectionWebSocket_isConnecting, "f")) {
-                reject("message" in err ? new ConnectionError(err.message) : new ConnectionError("Connection failed"));
-            }
-            if (this.connected) {
-                L.error(err);
-            }
-        });
-    });
-}, _ConnectionWebSocket_assertConnected = function _ConnectionWebSocket_assertConnected() {
-    if (!this.connected) {
-        throw errConnectionNotOpen;
-    }
-}, _ConnectionWebSocket_rejectRead = function _ConnectionWebSocket_rejectRead() {
-    if (__classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f") != null) {
-        __classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f")[1].reject(errConnectionNotOpen);
-        __classPrivateFieldSet(this, _ConnectionWebSocket_nextResolve, null, "f");
-    }
-};

package/esm/deps/jsr.io/@roj/tgcrypto/1.0.1/dist/tgcrypto.js

@@ -1,5 +1,5 @@
 var Module = (() => {
-    var _scriptName = import.meta.url;
+    var _scriptName = globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url;
     return (function (moduleArg = {}) {
         var moduleRtn;
         var Module = moduleArg;
@@ -117,16 +117,8 @@ var Module = (() => {
             }
         } wasmBinaryFile ??= findWasmBinary(); instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject); return {}; }
         class ExitStatus {
-            constructor(status) {
-                Object.defineProperty(this, "name", {
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                    value: "ExitStatus"
-                });
-                this.message = `Program terminated with exit(${status})`;
-                this.status = status;
-            }
+            name = "ExitStatus";
+            constructor(status) { this.message = `Program terminated with exit(${status})`; this.status = status; }
         }
         var callRuntimeCallbacks = callbacks => { while (callbacks.length > 0) {
             callbacks.shift()(Module);

package/{script/deps/jsr.io/@std/assert/1.0.13 → esm/deps/jsr.io/@std/assert/1.0.14}/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.13/assert.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAI5D"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/assert.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAI5D"}

package/esm/deps/jsr.io/@std/assert/1.0.14/assertion_error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=assertion_error.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.14/assertion_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/esm/deps/jsr.io/@std/assert/1.0.14/assertion_error.js

@@ -0,0 +1,30 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AssertionError";
+    }
+}

package/esm/deps/jsr.io/@std/assert/{1.0.13 → 1.0.14}/equal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.13/equal.ts"],"names":[],"mappings":"AA2FA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAuGrD"}
+{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/equal.ts"],"names":[],"mappings":"AA2FA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAuGrD"}

package/esm/deps/jsr.io/@std/assert/{1.0.13 → 1.0.14}/equals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.13/equals.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAkBb"}
+{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/equals.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAkBb"}

package/esm/deps/jsr.io/@std/assert/{1.0.13 → 1.0.14}/false.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"false.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.13/false.ts"],"names":[],"mappings":"AAIA,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAI1E"}
+{"version":3,"file":"false.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/false.ts"],"names":[],"mappings":"AAIA,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAI1E"}

package/esm/deps/jsr.io/@std/assert/1.0.14/unreachable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unreachable } from "@std/assert";
+ *
+ * unreachable(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export declare function unreachable(msg?: string): never;
+//# sourceMappingURL=unreachable.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.14/unreachable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unreachable.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/unreachable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAG/C"}

package/esm/deps/jsr.io/@std/assert/1.0.14/unreachable.js

@@ -0,0 +1,20 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unreachable } from "@std/assert";
+ *
+ * unreachable(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export function unreachable(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Unreachable${msgSuffix}`);
+}

package/esm/deps/jsr.io/@std/async/{1.0.13 → 1.0.14}/_util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.13/_util.ts"],"names":[],"mappings":"AAGA,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,UAIf"}
+{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.14/_util.ts"],"names":[],"mappings":"AAGA,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,UAIf"}

package/esm/deps/jsr.io/@std/async/{1.0.13 → 1.0.14}/abortable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abortable.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.13/abortable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAClB,cAAc,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"abortable.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.14/abortable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAClB,cAAc,CAAC,CAAC,CAAC,CAAC"}

package/esm/deps/jsr.io/@std/async/{1.0.13 → 1.0.14}/deadline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.13/deadline.ts"],"names":[],"mappings":"AAKA,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EACb,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,CAAC,CAAC,CAIZ"}
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.14/deadline.ts"],"names":[],"mappings":"AAKA,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EACb,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,CAAC,CAAC,CAIZ"}

package/esm/deps/jsr.io/@std/async/{1.0.13 → 1.0.14}/debounce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.13/debounce.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,KAAK,CAAC,OAAO,CAAC;IACzD,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,4EAA4E;IAC5E,KAAK,IAAI,IAAI,CAAC;IACd,gFAAgF;IAChF,KAAK,IAAI,IAAI,CAAC;IACd,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAC3C,EAAE,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,EACpD,IAAI,EAAE,MAAM,GACX,iBAAiB,CAAC,CAAC,CAAC,CA8BtB"}
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.14/debounce.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,KAAK,CAAC,OAAO,CAAC;IACzD,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,4EAA4E;IAC5E,KAAK,IAAI,IAAI,CAAC;IACd,gFAAgF;IAChF,KAAK,IAAI,IAAI,CAAC;IACd,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAC3C,EAAE,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,EACpD,IAAI,EAAE,MAAM,GACX,iBAAiB,CAAC,CAAC,CAAC,CA8BtB"}

package/esm/deps/jsr.io/@std/async/{1.0.13 → 1.0.14}/delay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.13/delay.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B3E"}
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.14/delay.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B3E"}