@mtkruto/browser 0.119.0 → 0.119.1

package/esm/tl/1_tl_writer.js

@@ -18,27 +18,15 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 // deno-lint-ignore-file no-explicit-any
-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 _TLWriter_instances, _TLWriter_path, _TLWriter_serialize, _TLWriter_serializeVector, _TLWriter_serializePrimitive, _TLWriter_isTypeValid;
 import { concat } from "../0_deps.js";
 import { TLError } from "../0_errors.js";
 import { analyzeOptionalParam, BOOL_FALSE, BOOL_TRUE, getOptionalParamInnerType, getVectorItemType, isOptionalParam, repr, VECTOR } from "./0_utilities.js";
 import { intToBytes } from "../utilities/0_int.js";
 import { encodeText } from "../1_utilities.js";
 export class TLWriter {
+    _buffer = new Uint8Array();
+    #path = new Array();
     constructor() {
-        _TLWriter_instances.add(this);
-        Object.defineProperty(this, "_buffer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Uint8Array()
-        });
-        _TLWriter_path.set(this, new Array());
     }
     get buffer() {
         return this._buffer;
@@ -48,15 +36,15 @@ export class TLWriter {
         return this;
     }
     writeInt24(int, isSigned = true) {
-        this.write(intToBytes(int, 24 / 8, { isSigned, path: __classPrivateFieldGet(this, _TLWriter_path, "f") }));
+        this.write(intToBytes(int, 24 / 8, { isSigned, path: this.#path }));
         return this;
     }
     writeInt32(int, isSigned = true) {
-        this.write(intToBytes(int, 32 / 8, { isSigned, path: __classPrivateFieldGet(this, _TLWriter_path, "f") }));
+        this.write(intToBytes(int, 32 / 8, { isSigned, path: this.#path }));
         return this;
     }
     writeInt64(int, isSigned = true) {
-        this.write(intToBytes(int, 64 / 8, { isSigned, path: __classPrivateFieldGet(this, _TLWriter_path, "f") }));
+        this.write(intToBytes(int, 64 / 8, { isSigned, path: this.#path }));
         return this;
     }
     writeDouble(double) {
@@ -66,11 +54,11 @@ export class TLWriter {
         return this;
     }
     writeInt128(int, isSigned = true) {
-        this.write(intToBytes(int, 128 / 8, { isSigned, path: __classPrivateFieldGet(this, _TLWriter_path, "f") }));
+        this.write(intToBytes(int, 128 / 8, { isSigned, path: this.#path }));
         return this;
     }
     writeInt256(int, isSigned = true) {
-        this.write(intToBytes(int, 256 / 8, { isSigned, path: __classPrivateFieldGet(this, _TLWriter_path, "f") }));
+        this.write(intToBytes(int, 256 / 8, { isSigned, path: this.#path }));
         return this;
     }
     writeBytes(bytes) {
@@ -96,183 +84,186 @@ export class TLWriter {
         return this;
     }
     writeObject(value, schema) {
-        __classPrivateFieldGet(this, _TLWriter_instances, "m", _TLWriter_serialize).call(this, value._, value, schema);
+        this.#serialize(value._, value, schema);
         return this;
     }
-}
-_TLWriter_path = new WeakMap(), _TLWriter_instances = new WeakSet(), _TLWriter_serialize = function _TLWriter_serialize(type, value, schema) {
-    if (__classPrivateFieldGet(this, _TLWriter_instances, "m", _TLWriter_serializePrimitive).call(this, type, value)) {
-        return;
-    }
-    if (__classPrivateFieldGet(this, _TLWriter_instances, "m", _TLWriter_serializeVector).call(this, type, value, schema)) {
-        return;
-    }
-    const maybeDefinition = schema.definitions[value._];
-    if (!maybeDefinition) {
-        throw new TLError(`Unknown constructor: ${value._}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
-    }
-    if (type !== "!X" && !__classPrivateFieldGet(this, _TLWriter_instances, "m", _TLWriter_isTypeValid).call(this, type, value, schema)) {
-        throw new TLError(`Expected ${type} but instead got ${value._}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
-    }
-    const type__ = value;
-    const [id, parameters_] = maybeDefinition;
-    this.writeInt32(id, false);
-    let isFirstPathElementExisting = false;
-    for (let [name, type] of parameters_.values()) {
-        if (isOptionalParam(type) && type__[name] === undefined) {
-            continue;
+    #serialize(type, value, schema) {
+        if (this.#serializePrimitive(type, value)) {
+            return;
         }
-        if (type === "#") {
-            let flags = 0;
-            const flagField_ = name;
-            for (const [name, type] of parameters_) {
-                if (isOptionalParam(type)) {
-                    const { flagField, bitIndex } = analyzeOptionalParam(type);
-                    if (flagField === flagField_) {
-                        if (type__[name] !== undefined) {
-                            flags |= 1 << bitIndex;
-                        }
-                    }
-                }
-            }
-            this.writeInt32(flags);
-            continue;
+        if (this.#serializeVector(type, value, schema)) {
+            return;
         }
-        const pathElement = `[${value._}.]${name}`;
-        if (isFirstPathElementExisting) {
-            __classPrivateFieldGet(this, _TLWriter_path, "f")[__classPrivateFieldGet(this, _TLWriter_path, "f").length - 1] = pathElement;
+        const maybeDefinition = schema.definitions[value._];
+        if (!maybeDefinition) {
+            throw new TLError(`Unknown constructor: ${value._}`, this.#path);
         }
-        else {
-            __classPrivateFieldGet(this, _TLWriter_path, "f").push(pathElement);
-            isFirstPathElementExisting = true;
+        if (type !== "!X" && !this.#isTypeValid(type, value, schema)) {
+            throw new TLError(`Expected ${type} but instead got ${value._}`, this.#path);
         }
-        if (type__[name] === undefined && !isOptionalParam(type)) {
-            throw new TLError("Missing required field", __classPrivateFieldGet(this, _TLWriter_path, "f"));
-        }
-        if (isOptionalParam(type)) {
-            type = getOptionalParamInnerType(type);
-        }
-        __classPrivateFieldGet(this, _TLWriter_instances, "m", _TLWriter_serialize).call(this, type, type__[name], schema);
-    }
-    return;
-}, _TLWriter_serializeVector = function _TLWriter_serializeVector(type, value, schema) {
-    const itemType = getVectorItemType(type);
-    if (!itemType) {
-        return false;
-    }
-    if (!Array.isArray(value)) {
-        throw new TLError(`Expected an array but received ${repr(value)}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
-    }
-    this.writeInt32(VECTOR, false);
-    this.writeInt32(value.length);
-    for (const item of value) {
-        __classPrivateFieldGet(this, _TLWriter_instances, "m", _TLWriter_serialize).call(this, itemType, item, schema);
-    }
-    return true;
-}, _TLWriter_serializePrimitive = function _TLWriter_serializePrimitive(type, value) {
-    const valueRepr = repr(value);
-    switch (type) {
-        case "bytes":
-            if ((value instanceof Uint8Array)) {
-                this.writeBytes(value);
+        const type__ = value;
+        const [id, parameters_] = maybeDefinition;
+        this.writeInt32(id, false);
+        let isFirstPathElementExisting = false;
+        for (let [name, type] of parameters_.values()) {
+            if (isOptionalParam(type) && type__[name] === undefined) {
+                continue;
             }
-            else {
-                throw new TLError(`Expected Uint8Array but received ${valueRepr}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
-            }
-            return true;
-        case "int128":
-            if (typeof value === "bigint") {
-                this.writeInt128(value);
-            }
-            else {
-                throw new TLError(`Expected bigint but received ${valueRepr}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
+            if (type === "#") {
+                let flags = 0;
+                const flagField_ = name;
+                for (const [name, type] of parameters_) {
+                    if (isOptionalParam(type)) {
+                        const { flagField, bitIndex } = analyzeOptionalParam(type);
+                        if (flagField === flagField_) {
+                            if (type__[name] !== undefined) {
+                                flags |= 1 << bitIndex;
+                            }
+                        }
+                    }
+                }
+                this.writeInt32(flags);
+                continue;
             }
-            return true;
-        case "int256":
-            if (typeof value === "bigint") {
-                this.writeInt256(value);
+            const pathElement = `[${value._}.]${name}`;
+            if (isFirstPathElementExisting) {
+                this.#path[this.#path.length - 1] = pathElement;
             }
             else {
-                throw new TLError(`Expected bigint but received ${valueRepr}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
+                this.#path.push(pathElement);
+                isFirstPathElementExisting = true;
             }
-            return true;
-        case "long":
-            if (typeof value === "bigint") {
-                this.writeInt64(value);
+            if (type__[name] === undefined && !isOptionalParam(type)) {
+                throw new TLError("Missing required field", this.#path);
             }
-            else {
-                throw new TLError(`Expected bigint but received ${valueRepr}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
+            if (isOptionalParam(type)) {
+                type = getOptionalParamInnerType(type);
             }
-            return true;
-        case "Bool":
-            if (typeof value === "boolean") {
-                if (value) {
-                    this.writeInt32(BOOL_TRUE);
+            this.#serialize(type, type__[name], schema);
+        }
+        return;
+    }
+    #serializeVector(type, value, schema) {
+        const itemType = getVectorItemType(type);
+        if (!itemType) {
+            return false;
+        }
+        if (!Array.isArray(value)) {
+            throw new TLError(`Expected an array but received ${repr(value)}`, this.#path);
+        }
+        this.writeInt32(VECTOR, false);
+        this.writeInt32(value.length);
+        for (const item of value) {
+            this.#serialize(itemType, item, schema);
+        }
+        return true;
+    }
+    #serializePrimitive(type, value) {
+        const valueRepr = repr(value);
+        switch (type) {
+            case "bytes":
+                if ((value instanceof Uint8Array)) {
+                    this.writeBytes(value);
                 }
                 else {
-                    this.writeInt32(BOOL_FALSE);
+                    throw new TLError(`Expected Uint8Array but received ${valueRepr}`, this.#path);
                 }
-            }
-            else {
-                throw new TLError(`Expected boolean but received ${valueRepr}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
-            }
-            return true;
-        case "int":
-            //
-            if (value === null) {
-                value = 0;
-            }
-            //
-            if (typeof value === "number") {
-                if (value % 1 === 0) {
-                    this.writeInt32(value);
+                return true;
+            case "int128":
+                if (typeof value === "bigint") {
+                    this.writeInt128(value);
                 }
                 else {
-                    throw new TLError("Expected an integer value but received a floating point", __classPrivateFieldGet(this, _TLWriter_path, "f"));
+                    throw new TLError(`Expected bigint but received ${valueRepr}`, this.#path);
                 }
-            }
-            else {
-                throw new TLError(`Expected number but received ${valueRepr}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
-            }
-            return true;
-        case "double":
-            //
-            if (value === null) {
-                value = 0;
-            }
-            //
-            if (typeof value === "number") {
-                this.writeDouble(value);
-            }
-            else {
-                throw new TLError(`Expected number but received ${valueRepr}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
-            }
-            return true;
-        case "string":
-            if (typeof value === "string") {
-                this.writeString(value);
-            }
-            else if (value instanceof Uint8Array) {
-                this.writeBytes(value);
-            }
-            else {
-                this.writeString("");
-            }
-            // else {
-            //   throw new TypeError(`Expected string or Uint8Array but received ${valueRepr}`);
-            // }
-            return true;
-        case "true":
-            if (value !== true) {
-                throw new TLError(`Expected \`true\` but received ${valueRepr}`, __classPrivateFieldGet(this, _TLWriter_path, "f"));
-            }
-            return true;
-        default:
-            return false;
+                return true;
+            case "int256":
+                if (typeof value === "bigint") {
+                    this.writeInt256(value);
+                }
+                else {
+                    throw new TLError(`Expected bigint but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "long":
+                if (typeof value === "bigint") {
+                    this.writeInt64(value);
+                }
+                else {
+                    throw new TLError(`Expected bigint but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "Bool":
+                if (typeof value === "boolean") {
+                    if (value) {
+                        this.writeInt32(BOOL_TRUE);
+                    }
+                    else {
+                        this.writeInt32(BOOL_FALSE);
+                    }
+                }
+                else {
+                    throw new TLError(`Expected boolean but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "int":
+                //
+                if (value === null) {
+                    value = 0;
+                }
+                //
+                if (typeof value === "number") {
+                    if (value % 1 === 0) {
+                        this.writeInt32(value);
+                    }
+                    else {
+                        throw new TLError("Expected an integer value but received a floating point", this.#path);
+                    }
+                }
+                else {
+                    throw new TLError(`Expected number but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "double":
+                //
+                if (value === null) {
+                    value = 0;
+                }
+                //
+                if (typeof value === "number") {
+                    this.writeDouble(value);
+                }
+                else {
+                    throw new TLError(`Expected number but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            case "string":
+                if (typeof value === "string") {
+                    this.writeString(value);
+                }
+                else if (value instanceof Uint8Array) {
+                    this.writeBytes(value);
+                }
+                else {
+                    this.writeString("");
+                }
+                // else {
+                //   throw new TypeError(`Expected string or Uint8Array but received ${valueRepr}`);
+                // }
+                return true;
+            case "true":
+                if (value !== true) {
+                    throw new TLError(`Expected \`true\` but received ${valueRepr}`, this.#path);
+                }
+                return true;
+            default:
+                return false;
+        }
     }
-}, _TLWriter_isTypeValid = function _TLWriter_isTypeValid(type, value, schema) {
-    if (type === value._) {
-        return true;
+    #isTypeValid(type, value, schema) {
+        if (type === value._) {
+            return true;
+        }
+        return schema.definitions[value._]?.[2] === type;
     }
-    return schema.definitions[value._]?.[2] === type;
-};
+}

package/esm/transport/0_transport.js

@@ -18,14 +18,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 export class Transport {
-    constructor() {
-        Object.defineProperty(this, "obfuscationParameters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-    }
+    obfuscationParameters = null;
     async encrypt(buffer) {
         if (this.obfuscationParameters) {
             return await this.obfuscationParameters.encryptionCTR.call(buffer);

package/esm/transport/1_transport_abridged.js

@@ -17,57 +17,45 @@
  * 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 _TransportAbridged_connection, _TransportAbridged_obfuscated;
 import { concat } from "../0_deps.js";
 import { intFromBytes, intToBytes } from "../1_utilities.js";
 import { getObfuscationParameters } from "./0_obfuscation.js";
 import { Transport } from "./0_transport.js";
 export class TransportAbridged extends Transport {
+    #connection;
+    #obfuscated;
     constructor(connection, obfuscated = false) {
         super();
-        _TransportAbridged_connection.set(this, void 0);
-        _TransportAbridged_obfuscated.set(this, void 0);
-        __classPrivateFieldSet(this, _TransportAbridged_connection, connection, "f");
-        __classPrivateFieldSet(this, _TransportAbridged_obfuscated, obfuscated, "f");
+        this.#connection = connection;
+        this.#obfuscated = obfuscated;
     }
     async initialize() {
-        if (__classPrivateFieldGet(this, _TransportAbridged_obfuscated, "f")) {
-            this.obfuscationParameters = await getObfuscationParameters(0xEFEFEFEF, __classPrivateFieldGet(this, _TransportAbridged_connection, "f"));
+        if (this.#obfuscated) {
+            this.obfuscationParameters = await getObfuscationParameters(0xEFEFEFEF, this.#connection);
         }
         else {
-            await __classPrivateFieldGet(this, _TransportAbridged_connection, "f").write(new Uint8Array([0xEF]));
+            await this.#connection.write(new Uint8Array([0xEF]));
         }
     }
     async receive() {
         let length;
         {
             let buffer = new Uint8Array(1);
-            await __classPrivateFieldGet(this, _TransportAbridged_connection, "f").read(buffer);
+            await this.#connection.read(buffer);
             buffer = await this.decrypt(buffer);
             if (buffer[0] < 0x7F) {
                 length = buffer[0];
             }
             else {
                 let buffer = new Uint8Array(3);
-                await __classPrivateFieldGet(this, _TransportAbridged_connection, "f").read(buffer);
+                await this.#connection.read(buffer);
                 buffer = await this.decrypt(buffer);
                 length = Number(intFromBytes(buffer, { isSigned: false }));
             }
         }
         length *= 4;
         const buffer = new Uint8Array(length);
-        await __classPrivateFieldGet(this, _TransportAbridged_connection, "f").read(buffer);
+        await this.#connection.read(buffer);
         return await this.decrypt(buffer);
     }
     async send(buffer) {
@@ -75,7 +63,6 @@ export class TransportAbridged extends Transport {
         const header = new Uint8Array([bufferLength >= 0x7F ? 0x7F : bufferLength]);
         const length = bufferLength >= 0x7F ? intToBytes(bufferLength, 3, { isSigned: false }) : new Uint8Array();
         const data = concat([header, length, buffer]);
-        await __classPrivateFieldGet(this, _TransportAbridged_connection, "f").write(await this.encrypt(data));
+        await this.#connection.write(await this.encrypt(data));
     }
 }
-_TransportAbridged_connection = new WeakMap(), _TransportAbridged_obfuscated = new WeakMap();

package/esm/transport/1_transport_intermediate.js

@@ -17,55 +17,42 @@
  * 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 _TransportIntermediate_connection, _TransportIntermediate_obfuscated;
 import { concat } from "../0_deps.js";
 import { intToBytes } from "../1_utilities.js";
 import { getObfuscationParameters } from "./0_obfuscation.js";
 import { Transport } from "./0_transport.js";
 export class TransportIntermediate extends Transport {
+    #connection;
+    #obfuscated;
     constructor(connection, obfuscated = false) {
         super();
-        _TransportIntermediate_connection.set(this, void 0);
-        _TransportIntermediate_obfuscated.set(this, void 0);
-        __classPrivateFieldSet(this, _TransportIntermediate_connection, connection, "f");
-        __classPrivateFieldSet(this, _TransportIntermediate_obfuscated, obfuscated, "f");
+        this.#connection = connection;
+        this.#obfuscated = obfuscated;
     }
     async initialize() {
-        if (__classPrivateFieldGet(this, _TransportIntermediate_obfuscated, "f")) {
-            this.obfuscationParameters = await getObfuscationParameters(0xEEEEEEEE, __classPrivateFieldGet(this, _TransportIntermediate_connection, "f"));
+        if (this.#obfuscated) {
+            this.obfuscationParameters = await getObfuscationParameters(0xEEEEEEEE, this.#connection);
         }
         else {
-            await __classPrivateFieldGet(this, _TransportIntermediate_connection, "f").write(new Uint8Array([0xEE, 0xEE, 0xEE, 0xEE]));
+            await this.#connection.write(new Uint8Array([0xEE, 0xEE, 0xEE, 0xEE]));
         }
     }
     async receive() {
         let length;
         {
             let buffer = new Uint8Array(4);
-            await __classPrivateFieldGet(this, _TransportIntermediate_connection, "f").read(buffer);
+            await this.#connection.read(buffer);
             buffer = await this.decrypt(buffer);
             const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
             length = dataView.getUint32(0, true);
         }
         const buffer = new Uint8Array(length);
-        await __classPrivateFieldGet(this, _TransportIntermediate_connection, "f").read(buffer);
+        await this.#connection.read(buffer);
         return await this.decrypt(buffer);
     }
     async send(buffer) {
         const length = intToBytes(buffer.length, 4);
         const data = concat([length, buffer]);
-        await __classPrivateFieldGet(this, _TransportIntermediate_connection, "f").write(await this.encrypt(data));
+        await this.#connection.write(await this.encrypt(data));
     }
 }
-_TransportIntermediate_connection = new WeakMap(), _TransportIntermediate_obfuscated = new WeakMap();

package/esm/utilities/0_mutex.js

@@ -17,29 +17,14 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _Mutex_untilUnlock;
 export class Mutex {
-    constructor() {
-        _Mutex_untilUnlock.set(this, Promise.resolve());
-    }
+    #untilUnlock = Promise.resolve();
     async lock() {
-        await __classPrivateFieldGet(this, _Mutex_untilUnlock, "f");
+        await this.#untilUnlock;
         return new Promise((resolve0) => {
-            __classPrivateFieldSet(this, _Mutex_untilUnlock, new Promise((resolve1) => {
+            this.#untilUnlock = new Promise((resolve1) => {
                 resolve0(resolve1);
-            }), "f");
+            });
         });
     }
 }
-_Mutex_untilUnlock = new WeakMap();