@mtkruto/node 0.67.2 → 0.68.0

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

@@ -17,97 +17,90 @@
  * 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) => {
+                    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.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/esm/deps/jsr.io/@std/async/1.0.13/mux_async_iterator.js

@@ -1,17 +1,5 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 // This module is browser compatible.
-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 _MuxAsyncIterator_instances, _MuxAsyncIterator_iteratorCount, _MuxAsyncIterator_yields, _MuxAsyncIterator_throws, _MuxAsyncIterator_signal, _MuxAsyncIterator_callIteratorNext;
 /**
  * Multiplexes multiple async iterators into a single stream. It currently
  * makes an assumption that the final result (the value returned and not
@@ -47,14 +35,11 @@ var _MuxAsyncIterator_instances, _MuxAsyncIterator_iteratorCount, _MuxAsyncItera
  * @typeParam T The type of the provided async iterables and generated async iterable.
  */
 export class MuxAsyncIterator {
-    constructor() {
-        _MuxAsyncIterator_instances.add(this);
-        _MuxAsyncIterator_iteratorCount.set(this, 0);
-        _MuxAsyncIterator_yields.set(this, []);
-        // deno-lint-ignore no-explicit-any
-        _MuxAsyncIterator_throws.set(this, []);
-        _MuxAsyncIterator_signal.set(this, Promise.withResolvers());
-    }
+    #iteratorCount = 0;
+    #yields = [];
+    // deno-lint-ignore no-explicit-any
+    #throws = [];
+    #signal = Promise.withResolvers();
     /**
      * Add an async iterable to the stream.
      *
@@ -80,9 +65,23 @@ export class MuxAsyncIterator {
      * ```
      */
     add(iterable) {
-        var _a;
-        __classPrivateFieldSet(this, _MuxAsyncIterator_iteratorCount, (_a = __classPrivateFieldGet(this, _MuxAsyncIterator_iteratorCount, "f"), ++_a), "f");
-        __classPrivateFieldGet(this, _MuxAsyncIterator_instances, "m", _MuxAsyncIterator_callIteratorNext).call(this, iterable[Symbol.asyncIterator]());
+        ++this.#iteratorCount;
+        this.#callIteratorNext(iterable[Symbol.asyncIterator]());
+    }
+    async #callIteratorNext(iterator) {
+        try {
+            const { value, done } = await iterator.next();
+            if (done) {
+                --this.#iteratorCount;
+            }
+            else {
+                this.#yields.push({ iterator, value });
+            }
+        }
+        catch (e) {
+            this.#throws.push(e);
+        }
+        this.#signal.resolve();
     }
     /**
      * Returns an async iterator of the stream.
@@ -108,22 +107,22 @@ export class MuxAsyncIterator {
      * ```
      */
     async *iterate() {
-        while (__classPrivateFieldGet(this, _MuxAsyncIterator_iteratorCount, "f") > 0) {
+        while (this.#iteratorCount > 0) {
             // Sleep until any of the wrapped iterators yields.
-            await __classPrivateFieldGet(this, _MuxAsyncIterator_signal, "f").promise;
+            await this.#signal.promise;
             // Note that while we're looping over `yields`, new items may be added.
-            for (const { iterator, value } of __classPrivateFieldGet(this, _MuxAsyncIterator_yields, "f")) {
+            for (const { iterator, value } of this.#yields) {
                 yield value;
-                __classPrivateFieldGet(this, _MuxAsyncIterator_instances, "m", _MuxAsyncIterator_callIteratorNext).call(this, iterator);
+                this.#callIteratorNext(iterator);
             }
-            if (__classPrivateFieldGet(this, _MuxAsyncIterator_throws, "f").length) {
-                for (const e of __classPrivateFieldGet(this, _MuxAsyncIterator_throws, "f")) {
+            if (this.#throws.length) {
+                for (const e of this.#throws) {
                     throw e;
                 }
             }
             // Clear the `yields` list and reset the `signal` promise.
-            __classPrivateFieldGet(this, _MuxAsyncIterator_yields, "f").length = 0;
-            __classPrivateFieldSet(this, _MuxAsyncIterator_signal, Promise.withResolvers(), "f");
+            this.#yields.length = 0;
+            this.#signal = Promise.withResolvers();
         }
     }
     /**
@@ -149,22 +148,7 @@ export class MuxAsyncIterator {
      * assertEquals(result, [1, 2, 3]);
      * ```
      */
-    [(_MuxAsyncIterator_iteratorCount = new WeakMap(), _MuxAsyncIterator_yields = new WeakMap(), _MuxAsyncIterator_throws = new WeakMap(), _MuxAsyncIterator_signal = new WeakMap(), _MuxAsyncIterator_instances = new WeakSet(), _MuxAsyncIterator_callIteratorNext = async function _MuxAsyncIterator_callIteratorNext(iterator) {
-        var _a;
-        try {
-            const { value, done } = await iterator.next();
-            if (done) {
-                __classPrivateFieldSet(this, _MuxAsyncIterator_iteratorCount, (_a = __classPrivateFieldGet(this, _MuxAsyncIterator_iteratorCount, "f"), --_a), "f");
-            }
-            else {
-                __classPrivateFieldGet(this, _MuxAsyncIterator_yields, "f").push({ iterator, value });
-            }
-        }
-        catch (e) {
-            __classPrivateFieldGet(this, _MuxAsyncIterator_throws, "f").push(e);
-        }
-        __classPrivateFieldGet(this, _MuxAsyncIterator_signal, "f").resolve();
-    }, Symbol.asyncIterator)]() {
+    [Symbol.asyncIterator]() {
         return this.iterate();
     }
 }

package/esm/deps/jsr.io/@std/async/1.0.13/tee.js

@@ -1,57 +1,34 @@
 // 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 _Queue_source, _Queue_queue;
 class Queue {
+    #source;
+    #queue;
+    head;
+    done;
     constructor(iterable) {
-        _Queue_source.set(this, void 0);
-        _Queue_queue.set(this, void 0);
-        Object.defineProperty(this, "head", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "done", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        __classPrivateFieldSet(this, _Queue_source, iterable[Symbol.asyncIterator](), "f");
-        __classPrivateFieldSet(this, _Queue_queue, {
+        this.#source = iterable[Symbol.asyncIterator]();
+        this.#queue = {
             value: undefined,
             next: undefined,
-        }, "f");
-        this.head = __classPrivateFieldGet(this, _Queue_queue, "f");
+        };
+        this.head = this.#queue;
         this.done = false;
     }
     async next() {
-        const result = await __classPrivateFieldGet(this, _Queue_source, "f").next();
+        const result = await this.#source.next();
         if (!result.done) {
             const nextNode = {
                 value: result.value,
                 next: undefined,
             };
-            __classPrivateFieldGet(this, _Queue_queue, "f").next = nextNode;
-            __classPrivateFieldSet(this, _Queue_queue, nextNode, "f");
+            this.#queue.next = nextNode;
+            this.#queue = nextNode;
         }
         else {
             this.done = true;
         }
     }
 }
-_Queue_source = new WeakMap(), _Queue_queue = new WeakMap();
 /**
  * Branches the given async iterable into the `n` branches.
  *

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();