@mtkruto/browser 0.119.0 → 0.119.1

package/esm/client/7_client_worker.js

@@ -17,36 +17,24 @@
  * 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 _ClientWorker_worker, _ClientWorker_clients, _ClientWorker_L;
 import { InputError } from "../0_errors.js";
 import { getLogger } from "../utilities/1_logger.js";
 import { ClientDispatcher } from "./6_client_dispatcher.js";
 export class ClientWorker {
+    #worker;
+    #clients = new Map();
+    #L = getLogger("ClientWorker");
     constructor(worker) {
-        _ClientWorker_worker.set(this, void 0);
-        _ClientWorker_clients.set(this, new Map());
-        _ClientWorker_L.set(this, getLogger("ClientWorker"));
-        __classPrivateFieldSet(this, _ClientWorker_worker, worker, "f");
-        __classPrivateFieldGet(this, _ClientWorker_worker, "f").addEventListener("message", async (e) => {
+        this.#worker = worker;
+        this.#worker.addEventListener("message", async (e) => {
             const message = e.data;
-            __classPrivateFieldGet(this, _ClientWorker_L, "f").debug("received message from worker", message);
+            this.#L.debug("received message from worker", message);
             if (message.type === "response") {
-                __classPrivateFieldGet(this, _ClientWorker_clients, "f").get(message.clientId)?.handleResponse(message);
+                this.#clients.get(message.clientId)?.handleResponse(message);
             }
             else if (message.type === "request") {
                 if (message.method === "handleInvokeError") {
-                    const client = __classPrivateFieldGet(this, _ClientWorker_clients, "f").get(message.clientId);
+                    const client = this.#clients.get(message.clientId);
                     if (client) {
                         const result = await client.handleInvokeError(message);
                         const response = {
@@ -56,34 +44,33 @@ export class ClientWorker {
                             isError: false,
                             data: result,
                         };
-                        __classPrivateFieldGet(this, _ClientWorker_worker, "f").postMessage(response);
+                        this.#worker.postMessage(response);
                     }
                 }
             }
         });
     }
     async createClient(id, params) {
-        if (__classPrivateFieldGet(this, _ClientWorker_clients, "f").has(id)) {
+        if (this.#clients.has(id)) {
             throw new InputError("Client already created");
         }
-        const client = new ClientDispatcher(__classPrivateFieldGet(this, _ClientWorker_worker, "f"), id);
-        __classPrivateFieldGet(this, _ClientWorker_clients, "f").set(id, client);
+        const client = new ClientDispatcher(this.#worker, id);
+        this.#clients.set(id, client);
         try {
             await client.init(params);
         }
         catch (err) {
-            __classPrivateFieldGet(this, _ClientWorker_clients, "f").delete(id);
+            this.#clients.delete(id);
             throw err;
         }
         return client;
     }
     getClient(id) {
-        let client = __classPrivateFieldGet(this, _ClientWorker_clients, "f").get(id);
+        let client = this.#clients.get(id);
         if (!client) {
-            client = new ClientDispatcher(__classPrivateFieldGet(this, _ClientWorker_worker, "f"), id);
-            __classPrivateFieldGet(this, _ClientWorker_clients, "f").set(id, client);
+            client = new ClientDispatcher(this.#worker, id);
+            this.#clients.set(id, client);
         }
         return client;
     }
 }
-_ClientWorker_worker = new WeakMap(), _ClientWorker_clients = new WeakMap(), _ClientWorker_L = new WeakMap();

package/esm/connection/1_connection_tcp.js

@@ -17,127 +17,110 @@
  * 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_connection, _ConnectionTCP_rMutex, _ConnectionTCP_wMutex, _ConnectionTCP_buffer, _ConnectionTCP_nextResolve, _ConnectionTCP_canRead, _ConnectionTCP_canWrite, _ConnectionTCP_assertConnected, _ConnectionTCP_rejectRead;
 import { concat, iterateReader } from "../0_deps.js";
 import { ConnectionError } from "../0_errors.js";
 import { getLogger, Mutex } from "../1_utilities.js";
 const L = getLogger("ConnectionTCP");
 export class ConnectionTCP {
+    #hostname;
+    #port;
+    #connection;
+    #rMutex = new Mutex();
+    #wMutex = new Mutex();
+    #buffer = new Uint8Array();
+    #nextResolve = null;
+    #canRead = false;
+    #canWrite = false;
+    connect = Deno.connect;
+    stateChangeHandler;
+    callback;
     constructor(hostname, port) {
-        _ConnectionTCP_instances.add(this);
-        _ConnectionTCP_hostname.set(this, void 0);
-        _ConnectionTCP_port.set(this, void 0);
-        _ConnectionTCP_connection.set(this, void 0);
-        _ConnectionTCP_rMutex.set(this, new Mutex());
-        _ConnectionTCP_wMutex.set(this, new Mutex());
-        _ConnectionTCP_buffer.set(this, new Uint8Array());
-        _ConnectionTCP_nextResolve.set(this, null);
-        _ConnectionTCP_canRead.set(this, false);
-        _ConnectionTCP_canWrite.set(this, false);
-        Object.defineProperty(this, "connect", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: Deno.connect
-        });
-        Object.defineProperty(this, "stateChangeHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "callback", {
-            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;
     }
     get isConnected() {
-        return !!__classPrivateFieldGet(this, _ConnectionTCP_connection, "f") && __classPrivateFieldGet(this, _ConnectionTCP_canRead, "f") && __classPrivateFieldGet(this, _ConnectionTCP_canWrite, "f");
+        return !!this.#connection && this.#canRead && this.#canWrite;
+    }
+    #assertConnected() {
+        if (!this.isConnected) {
+            throw new ConnectionError("The connection is not open.");
+        }
     }
     async open() {
         if (this.isConnected) {
             return;
         }
         const connection = await this.connect({
-            hostname: __classPrivateFieldGet(this, _ConnectionTCP_hostname, "f"),
-            port: __classPrivateFieldGet(this, _ConnectionTCP_port, "f"),
+            hostname: this.#hostname,
+            port: this.#port,
         });
         connection.setNoDelay(true);
         connection.setKeepAlive(true);
-        __classPrivateFieldSet(this, _ConnectionTCP_canRead, __classPrivateFieldSet(this, _ConnectionTCP_canWrite, true, "f"), "f");
+        this.#canRead = this.#canWrite = true;
         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);
         Promise.resolve().then(async () => {
             do {
                 try {
                     for await (const chunk of iterateReader(connection)) {
                         this.callback?.read(chunk.length);
-                        __classPrivateFieldSet(this, _ConnectionTCP_buffer, concat([__classPrivateFieldGet(this, _ConnectionTCP_buffer, "f"), chunk]), "f");
-                        if (__classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f") !== null && __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").length >= __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[0]) {
-                            __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[1].resolve();
-                            __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, null, "f");
+                        this.#buffer = concat([this.#buffer, chunk]);
+                        if (this.#nextResolve !== null && this.#buffer.length >= this.#nextResolve[0]) {
+                            this.#nextResolve[1].resolve();
+                            this.#nextResolve = null;
                         }
                     }
-                    __classPrivateFieldSet(this, _ConnectionTCP_canRead, false, "f");
+                    this.#canRead = false;
                     break;
                 }
                 catch (err) {
-                    __classPrivateFieldSet(this, _ConnectionTCP_canRead, false, "f");
+                    this.#canRead = false;
                     this.stateChangeHandler?.(false);
-                    __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_rejectRead).call(this);
+                    this.#rejectRead();
                     L.error(err);
                 }
             } while (this.isConnected);
             this.stateChangeHandler?.(false);
         });
-        __classPrivateFieldSet(this, _ConnectionTCP_connection, connection, "f");
+        this.#connection = connection;
+    }
+    #rejectRead() {
+        if (this.#nextResolve !== null) {
+            this.#nextResolve[1].reject(new ConnectionError("The connection was closed."));
+            this.#nextResolve = null;
+        }
     }
     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 }]);
             }
-            const slice = __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").slice(0, p.length);
+            const slice = this.#buffer.slice(0, p.length);
             p.set(slice);
-            __classPrivateFieldSet(this, _ConnectionTCP_buffer, __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").slice(slice.length), "f");
+            this.#buffer = this.#buffer.slice(slice.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();
             let written = 0;
             while (written < p.length) {
                 try {
-                    const wrote = await __classPrivateFieldGet(this, _ConnectionTCP_connection, "f").write(p.subarray(written));
+                    const wrote = await this.#connection.write(p.subarray(written));
                     this.callback?.write(wrote);
                     written += wrote;
                 }
                 catch (err) {
                     if (err instanceof Deno.errors.BrokenPipe || err instanceof Deno.errors.ConnectionReset) {
-                        __classPrivateFieldSet(this, _ConnectionTCP_canWrite, false, "f");
+                        this.#canWrite = false;
                     }
                     if (!this.isConnected) {
                         this.stateChangeHandler?.(false);
@@ -154,20 +137,10 @@ export class ConnectionTCP {
         }
     }
     close() {
-        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
-        __classPrivateFieldGet(this, _ConnectionTCP_connection, "f").close();
-        __classPrivateFieldSet(this, _ConnectionTCP_canRead, __classPrivateFieldSet(this, _ConnectionTCP_canWrite, false, "f"), "f");
-        __classPrivateFieldSet(this, _ConnectionTCP_connection, undefined, "f");
-        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_rejectRead).call(this);
+        this.#assertConnected();
+        this.#connection.close();
+        this.#canRead = this.#canWrite = false;
+        this.#connection = undefined;
+        this.#rejectRead();
     }
 }
-_ConnectionTCP_hostname = new WeakMap(), _ConnectionTCP_port = new WeakMap(), _ConnectionTCP_connection = new WeakMap(), _ConnectionTCP_rMutex = new WeakMap(), _ConnectionTCP_wMutex = new WeakMap(), _ConnectionTCP_buffer = new WeakMap(), _ConnectionTCP_nextResolve = new WeakMap(), _ConnectionTCP_canRead = new WeakMap(), _ConnectionTCP_canWrite = new WeakMap(), _ConnectionTCP_instances = new WeakSet(), _ConnectionTCP_assertConnected = function _ConnectionTCP_assertConnected() {
-    if (!this.isConnected) {
-        throw new ConnectionError("The connection is not open.");
-    }
-}, _ConnectionTCP_rejectRead = function _ConnectionTCP_rejectRead() {
-    if (__classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f") !== null) {
-        __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[1].reject(new ConnectionError("The connection was closed."));
-        __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, null, "f");
-    }
-};

package/esm/connection/1_connection_web_socket.js

@@ -17,132 +17,116 @@
  * 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 _ConnectionWebSocket_instances, _ConnectionWebSocket_url, _ConnectionWebSocket_webSocket, _ConnectionWebSocket_rMutex, _ConnectionWebSocket_wMutex, _ConnectionWebSocket_buffer, _ConnectionWebSocket_nextResolve, _ConnectionWebSocket_initWs, _ConnectionWebSocket_isConnecting, _ConnectionWebSocket_assertConnected, _ConnectionWebSocket_rejectRead;
 import { concat, unreachable } from "../0_deps.js";
 import { ConnectionError } from "../0_errors.js";
 import { getLogger, Mutex } from "../1_utilities.js";
 const L = getLogger("ConnectionWebSocket");
 const errConnectionNotOpen = new ConnectionError("The connection is 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 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("Failed to connect."));
+                }
+                if (this.isConnected) {
+                    L.error(err);
+                }
+            });
         });
-        _ConnectionWebSocket_isConnecting.set(this, false);
-        __classPrivateFieldSet(this, _ConnectionWebSocket_url, url, "f");
     }
     get isConnected() {
-        return !!__classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f") && __classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").readyState === WebSocket.OPEN;
+        return !!this.#webSocket && this.#webSocket.readyState === WebSocket.OPEN;
     }
+    #isConnecting = false;
     async open() {
-        if (__classPrivateFieldGet(this, _ConnectionWebSocket_isConnecting, "f")) {
+        if (this.#isConnecting) {
             return;
         }
-        __classPrivateFieldSet(this, _ConnectionWebSocket_isConnecting, true, "f");
+        this.#isConnecting = true;
         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.isConnected) {
+            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 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("Failed to connect."));
-            }
-            if (this.isConnected) {
-                L.error(err);
-            }
-        });
-    });
-}, _ConnectionWebSocket_assertConnected = function _ConnectionWebSocket_assertConnected() {
-    if (!this.isConnected) {
-        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 = globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url;
+    var _scriptName = 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);