@freesignal/protocol 0.2.9 → 0.3.0

package/types.js

@@ -17,82 +17,163 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XFreeSignal = exports.DataEncoder = exports.EncryptedDataConstructor = exports.EncryptedData = exports.Datagram = exports.Protocols = exports.IdentityKeys = exports.UserId = void 0;
+exports.AsyncMap = exports.EncryptedData = exports.Datagram = exports.Protocols = exports.PrivateIdentityKey = exports.IdentityKey = exports.UserId = void 0;
 const utils_1 = require("@freesignal/utils");
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const double_ratchet_1 = require("./double-ratchet");
-const fflate_1 = __importDefault(require("fflate"));
-var UserId;
-(function (UserId) {
-    class UserIdConstructor {
-        constructor(array) {
-            this.array = array;
+class UserId {
+    constructor(array) {
+        this.array = array;
+    }
+    ;
+    toString() {
+        return (0, utils_1.decodeBase64)(this.array);
+    }
+    toJSON() {
+        return this.toString();
+    }
+    toUint8Array() {
+        return this.array;
+    }
+    static fromKey(identityKey) {
+        if (typeof identityKey === 'string')
+            identityKey = (0, utils_1.encodeBase64)(identityKey);
+        else if (IdentityKey.isIdentityKeys(identityKey))
+            identityKey = identityKey.toBytes();
+        return new UserId(crypto_1.default.hkdf(identityKey, new Uint8Array(32).fill(0), "/freesignal/userid"));
+    }
+    static from(userId) {
+        if (typeof userId === 'string')
+            userId = (0, utils_1.encodeBase64)(userId);
+        return new UserId(userId instanceof Uint8Array ? userId : userId.array);
+    }
+}
+exports.UserId = UserId;
+var IdentityKey;
+(function (IdentityKey) {
+    IdentityKey.keyLength = crypto_1.default.EdDSA.publicKeyLength + crypto_1.default.ECDH.publicKeyLength + 1;
+    const info = 0x70;
+    IdentityKey.version = 1;
+    class IdentityKeyConstructor {
+        constructor(identityKey) {
+            if (identityKey instanceof IdentityKeyConstructor) {
+                this.info = identityKey.info;
+                this.signatureKey = identityKey.signatureKey;
+                this.exchangeKey = identityKey.exchangeKey;
+            }
+            else {
+                if (typeof identityKey === 'string')
+                    identityKey = (0, utils_1.encodeBase64)(identityKey);
+                if (!isIdentityKeys(identityKey))
+                    throw new Error("Invalid key length");
+                this.info = identityKey[0];
+                this.signatureKey = identityKey.subarray(1, crypto_1.default.EdDSA.publicKeyLength + 1);
+                this.exchangeKey = identityKey.subarray(crypto_1.default.EdDSA.publicKeyLength + 1, IdentityKey.keyLength);
+            }
+        }
+        get userId() {
+            return UserId.fromKey(this.toBytes()).toString();
+        }
+        toBytes() {
+            return (0, utils_1.concatArrays)((0, utils_1.numberToArray)(this.info), this.signatureKey, this.exchangeKey);
         }
-        ;
         toString() {
-            return (0, utils_1.decodeBase64)(this.array);
+            return (0, utils_1.decodeBase64)(this.toBytes());
         }
         toJSON() {
             return this.toString();
         }
-        toUint8Array() {
-            return this.array;
-        }
     }
-    function getUserId(publicKey) {
-        return new UserIdConstructor(crypto_1.default.hash(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey)));
-    }
-    UserId.getUserId = getUserId;
-    function from(userId) {
-        return new UserIdConstructor(userId instanceof Uint8Array ? userId : (0, utils_1.encodeBase64)(userId));
-    }
-    UserId.from = from;
-})(UserId || (exports.UserId = UserId = {}));
-var IdentityKeys;
-(function (IdentityKeys) {
-    IdentityKeys.keyLength = crypto_1.default.ECDH.publicKeyLength;
-    class IdentityKeysConstructor {
-        constructor(identityKeys) {
-            if (typeof identityKeys === 'string')
-                identityKeys = (0, utils_1.encodeBase64)(identityKeys);
-            if (identityKeys instanceof Uint8Array) {
-                this.publicKey = (0, utils_1.decodeBase64)(identityKeys.subarray(0, IdentityKeys.keyLength));
-                this.identityKey = (0, utils_1.decodeBase64)(identityKeys.subarray(IdentityKeys.keyLength));
+    function isIdentityKeys(obj) {
+        return (obj instanceof Uint8Array && obj.length === IdentityKey.keyLength) || obj instanceof IdentityKeyConstructor;
+    }
+    IdentityKey.isIdentityKeys = isIdentityKeys;
+    function from(...keys) {
+        keys = keys.map(key => {
+            if (key instanceof IdentityKeyConstructor)
+                return key.toBytes();
+            else if (typeof key === 'string')
+                return (0, utils_1.encodeBase64)(key);
+            else
+                return key;
+        });
+        return new IdentityKeyConstructor(keys.length === 2 ? (0, utils_1.concatArrays)((0, utils_1.numberToArray)(info + IdentityKey.version), ...keys) : keys[0]);
+    }
+    IdentityKey.from = from;
+})(IdentityKey || (exports.IdentityKey = IdentityKey = {}));
+var PrivateIdentityKey;
+(function (PrivateIdentityKey) {
+    PrivateIdentityKey.keyLength = crypto_1.default.EdDSA.secretKeyLength + crypto_1.default.ECDH.secretKeyLength + 1;
+    const info = 0x4E;
+    PrivateIdentityKey.version = 1;
+    class PrivateIdentityKeyConstructor {
+        constructor(privateIdentityKey) {
+            this.info = info + PrivateIdentityKey.version;
+            if (privateIdentityKey instanceof PrivateIdentityKeyConstructor) {
+                this.signatureKey = privateIdentityKey.signatureKey;
+                this.exchangeKey = privateIdentityKey.exchangeKey;
+                this.identityKey = privateIdentityKey.identityKey;
             }
             else {
-                this.publicKey = identityKeys.publicKey;
-                this.identityKey = identityKeys.identityKey;
+                if (typeof privateIdentityKey === 'string')
+                    privateIdentityKey = (0, utils_1.encodeBase64)(privateIdentityKey);
+                if (!isIdentityKeys(privateIdentityKey))
+                    throw new Error("Invalid key length");
+                this.signatureKey = privateIdentityKey.subarray(1, crypto_1.default.EdDSA.secretKeyLength + 1);
+                this.exchangeKey = privateIdentityKey.subarray(crypto_1.default.EdDSA.secretKeyLength + 1, PrivateIdentityKey.keyLength);
+                this.identityKey = IdentityKey.from(crypto_1.default.EdDSA.keyPair(this.signatureKey).publicKey, crypto_1.default.ECDH.keyPair(this.exchangeKey).publicKey);
             }
         }
-        encode() {
-            return (0, utils_1.concatArrays)((0, utils_1.encodeBase64)(this.publicKey), (0, utils_1.encodeBase64)(this.identityKey));
+        get userId() {
+            return UserId.fromKey(this.identityKey.toBytes()).toString();
+        }
+        toBytes() {
+            return (0, utils_1.concatArrays)((0, utils_1.numberToArray)(this.info), this.signatureKey, this.exchangeKey);
         }
         toString() {
-            throw (0, utils_1.decodeBase64)(this.encode());
+            return (0, utils_1.decodeBase64)(this.toBytes());
         }
         toJSON() {
-            throw this.toString();
+            return this.toString();
         }
     }
     function isIdentityKeys(obj) {
-        return (typeof obj === 'object' && obj.publicKey && obj.identityKey);
-    }
-    IdentityKeys.isIdentityKeys = isIdentityKeys;
-    function from(identityKeys) {
-        return new IdentityKeysConstructor(identityKeys);
+        return (obj instanceof Uint8Array && obj.length === PrivateIdentityKey.keyLength) || obj instanceof PrivateIdentityKeyConstructor;
+    }
+    PrivateIdentityKey.isIdentityKeys = isIdentityKeys;
+    function from(...keys) {
+        keys = keys.map(key => {
+            if (key instanceof PrivateIdentityKeyConstructor)
+                return key.toBytes();
+            else if (typeof key === 'string')
+                return (0, utils_1.encodeBase64)(key);
+            else
+                return key;
+        });
+        return new PrivateIdentityKeyConstructor(keys.length === 2 ? (0, utils_1.concatArrays)((0, utils_1.numberToArray)(info + PrivateIdentityKey.version), ...keys) : keys[0]);
     }
-    IdentityKeys.from = from;
-})(IdentityKeys || (exports.IdentityKeys = IdentityKeys = {}));
+    PrivateIdentityKey.from = from;
+})(PrivateIdentityKey || (exports.PrivateIdentityKey = PrivateIdentityKey = {}));
 var Protocols;
 (function (Protocols) {
     Protocols["NULL"] = "";
     Protocols["MESSAGE"] = "/freesignal/message";
     Protocols["RELAY"] = "/freesignal/relay";
     Protocols["HANDSHAKE"] = "/freesignal/handshake";
+    Protocols["DISCOVER"] = "/freesignal/discover";
 })(Protocols || (exports.Protocols = Protocols = {}));
 (function (Protocols) {
     function isProtocol(protocol) {
@@ -116,109 +197,92 @@ var Protocols;
     }
     Protocols.decode = decode;
 })(Protocols || (exports.Protocols = Protocols = {}));
-var Datagram;
-(function (Datagram) {
-    Datagram.version = 1;
-    class DatagramConstructor {
-        constructor(data, receiver, protocol, payload) {
-            if (!receiver && !protocol && !payload) {
-                if (data instanceof Uint8Array) {
-                    this.version = data[0] & 127;
-                    this.protocol = Protocols.decode(data.subarray(1, 2));
-                    this.id = crypto_1.default.UUID.stringify(data.subarray(2, 18));
-                    this.createdAt = (0, utils_1.numberFromArray)(data.subarray(18, 26));
-                    this.sender = (0, utils_1.decodeBase64)(data.subarray(26, 26 + crypto_1.default.EdDSA.publicKeyLength));
-                    this.receiver = (0, utils_1.decodeBase64)(data.subarray(26 + crypto_1.default.EdDSA.publicKeyLength, DatagramConstructor.headerOffset));
-                    if (data[0] & 128)
-                        this._signature = data.subarray(data.length - crypto_1.default.EdDSA.signatureLength);
-                    this._payload = data.subarray(DatagramConstructor.headerOffset, data.length);
-                }
-                else if (Datagram.isDatagram(data)) {
-                    const datagram = data;
-                    this.id = datagram.id;
-                    this.version = datagram.version;
-                    this.sender = datagram.sender;
-                    this.receiver = datagram.receiver;
-                    this.protocol = datagram.protocol;
-                    this.createdAt = datagram.createdAt;
-                    this._payload = datagram.payload;
-                    this._signature = (0, utils_1.encodeBase64)(datagram.signature);
-                }
-                else
-                    throw new Error('Invalid constructor arguments for Datagram');
-            }
-            else if (typeof data === 'string' || data instanceof Uint8Array) {
-                this.id = crypto_1.default.UUID.generate().toString();
-                this.version = Datagram.version;
-                this.sender = typeof data === 'string' ? data : (0, utils_1.decodeBase64)(data);
-                this.receiver = typeof receiver === 'string' ? receiver : (0, utils_1.decodeBase64)(receiver);
-                this.protocol = protocol;
-                this.createdAt = Date.now();
-                this._payload = payload instanceof Uint8Array ? payload : payload === null || payload === void 0 ? void 0 : payload.encode();
-            }
-            else
-                throw new Error('Invalid constructor arguments for Datagram');
-        }
-        get signed() {
-            return !this._signature && !this.secretKey ? false : true;
-        }
-        get signature() {
-            if (this.signed) {
-                if (!this._signature)
-                    this.encode();
-                return (0, utils_1.decodeBase64)(this._signature);
-            }
-        }
-        set payload(data) {
-            this._signature = undefined;
-            this._payload = data;
-        }
-        get payload() {
-            return this._payload;
-        }
-        encode() {
-            var _a, _b, _c;
-            const data = (0, utils_1.concatArrays)(new Uint8Array(1).fill(this.version | (this.secretKey ? 128 : 0)), //1
-            Protocols.encode(this.protocol), //1
-            (_a = crypto_1.default.UUID.parse(this.id)) !== null && _a !== void 0 ? _a : [], //16
-            (0, utils_1.numberToArray)(this.createdAt, 8), //8
-            (0, utils_1.encodeBase64)(this.sender), //32
-            (0, utils_1.encodeBase64)(this.receiver), //32
-            (_b = this._payload) !== null && _b !== void 0 ? _b : new Uint8Array());
-            if (this.secretKey)
-                this._signature = crypto_1.default.EdDSA.sign(data, this.secretKey);
-            return (0, utils_1.concatArrays)(data, (_c = this._signature) !== null && _c !== void 0 ? _c : new Uint8Array());
-        }
-        sign(secretKey) {
-            this.secretKey = secretKey;
-            return this;
-        }
-        toString() {
-            return (0, utils_1.decodeBase64)(this.encode());
-        }
-        toJSON() {
-            return this.toString();
+class Datagram {
+    constructor(sender, receiver, protocol, payload) {
+        this._id = crypto_1.default.UUID.generate().toString();
+        this._version = Datagram.version;
+        this.sender = typeof sender === 'string' ? sender : (0, utils_1.decodeBase64)(sender);
+        this.receiver = typeof receiver === 'string' ? receiver : (0, utils_1.decodeBase64)(receiver);
+        this.protocol = protocol;
+        this._createdAt = Date.now();
+        this._payload = payload instanceof Uint8Array ? payload : payload === null || payload === void 0 ? void 0 : payload.toBytes();
+    }
+    get id() {
+        return this._id;
+    }
+    get version() {
+        return this._version;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    get signed() {
+        return !!this._signature || !!this.secretKey;
+    }
+    get signature() {
+        if (this.signed) {
+            if (!this._signature)
+                this.toBytes();
+            return (0, utils_1.decodeBase64)(this._signature);
         }
     }
-    DatagramConstructor.headerOffset = 26 + crypto_1.default.EdDSA.publicKeyLength * 2;
-    function create(sender, receiver, protocol, payload) {
-        return new DatagramConstructor(sender, receiver, protocol, payload);
+    set payload(data) {
+        this._signature = undefined;
+        this._payload = data;
+    }
+    get payload() {
+        return this._payload;
+    }
+    toBytes() {
+        var _a, _b, _c;
+        const data = (0, utils_1.concatArrays)(new Uint8Array(1).fill(this.version | (this.secretKey ? 128 : 0)), //1
+        Protocols.encode(this.protocol), //1
+        (_a = crypto_1.default.UUID.parse(this.id)) !== null && _a !== void 0 ? _a : [], //16
+        (0, utils_1.numberToArray)(this.createdAt, 8), //8
+        (0, utils_1.encodeBase64)(this.sender), //32
+        (0, utils_1.encodeBase64)(this.receiver), //32
+        (_b = this._payload) !== null && _b !== void 0 ? _b : new Uint8Array());
+        if (this.secretKey)
+            this._signature = crypto_1.default.EdDSA.sign(data, this.secretKey);
+        return (0, utils_1.concatArrays)(data, (_c = this._signature) !== null && _c !== void 0 ? _c : new Uint8Array());
+    }
+    sign(secretKey) {
+        this.secretKey = secretKey;
+        return this;
     }
-    Datagram.create = create;
-    function isDatagram(obj) {
-        return obj instanceof DatagramConstructor || (obj && typeof obj === 'object' && 'id' in obj && 'version' in obj && 'sender' in obj && 'receiver' in obj && 'protocol' in obj && 'createdAt' in obj);
+    toString() {
+        return (0, utils_1.decodeBase64)(this.toBytes());
     }
-    Datagram.isDatagram = isDatagram;
-    function from(data) {
-        if (typeof data === 'string') {
-            const decoded = (0, utils_1.encodeBase64)(data);
-            return new DatagramConstructor(decoded);
+    toJSON() {
+        return this.toString();
+    }
+    static from(data) {
+        if (typeof data === 'string')
+            data = (0, utils_1.encodeBase64)(data);
+        if (data instanceof Uint8Array) {
+            const datagram = new Datagram((0, utils_1.decodeBase64)(data.subarray(26, 26 + crypto_1.default.EdDSA.publicKeyLength)), (0, utils_1.decodeBase64)(data.subarray(26 + crypto_1.default.EdDSA.publicKeyLength, Datagram.headerOffset)), Protocols.decode(data.subarray(1, 2)), data.subarray(Datagram.headerOffset, data.length));
+            datagram._version = data[0] & 127;
+            datagram._id = crypto_1.default.UUID.stringify(data.subarray(2, 18));
+            datagram._createdAt = (0, utils_1.numberFromArray)(data.subarray(18, 26));
+            if (data[0] & 128)
+                datagram._signature = data.subarray(data.length - crypto_1.default.EdDSA.signatureLength);
+            return datagram;
+        }
+        else if (data instanceof Datagram) {
+            const datagram = new Datagram(data.sender, data.receiver, data.protocol, data.payload);
+            datagram._id = datagram.id;
+            datagram._version = datagram.version;
+            datagram._createdAt = datagram.createdAt;
+            datagram._signature = datagram.signature ? (0, utils_1.encodeBase64)(datagram.signature) : undefined;
+            return datagram;
         }
         else
-            return new DatagramConstructor(data);
+            throw new Error('Invalid constructor arguments for Datagram');
     }
-    Datagram.from = from;
-})(Datagram || (exports.Datagram = Datagram = {}));
+}
+exports.Datagram = Datagram;
+Datagram.version = 1;
+Datagram.headerOffset = 26 + crypto_1.default.EdDSA.publicKeyLength * 2;
 class EncryptedData {
     /**
      * Static factory method that constructs an `EncryptedPayload` from a raw Uint8Array.
@@ -227,234 +291,42 @@ class EncryptedData {
      * @returns An instance of `EncryptedPayload`.
      */
     static from(array) {
-        return new EncryptedDataConstructor(array);
+        return new double_ratchet_1.EncryptedDataConstructor(array);
     }
 }
 exports.EncryptedData = EncryptedData;
-class EncryptedDataConstructor {
-    constructor(...arrays) {
-        arrays = arrays.filter(value => value !== undefined);
-        if (arrays[0] instanceof EncryptedDataConstructor) {
-            this.raw = arrays[0].raw;
-            return this;
-        }
-        if (typeof arrays[0] === 'number')
-            arrays[0] = (0, utils_1.numberToArray)(arrays[0], EncryptedDataConstructor.countLength);
-        if (typeof arrays[1] === 'number')
-            arrays[1] = (0, utils_1.numberToArray)(arrays[1], EncryptedDataConstructor.countLength);
-        if (arrays.length === 6) {
-            arrays.unshift(typeof arrays[5] === 'number' ? (0, utils_1.numberToArray)(arrays[5]) : arrays[5]);
-            arrays.pop();
-        }
-        else if (arrays.length > 1) {
-            arrays.unshift((0, utils_1.numberToArray)(double_ratchet_1.KeySession.version));
-        }
-        this.raw = (0, utils_1.concatArrays)(...arrays);
-    }
-    get length() { return this.raw.length; }
-    get version() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.version.get)); }
-    get count() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.count.get)); }
-    get previous() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.previous.get)); }
-    get publicKey() { return new Uint8Array(this.raw.buffer, ...Offsets.publicKey.get); }
-    get nonce() { return new Uint8Array(this.raw.buffer, ...Offsets.nonce.get); }
-    get ciphertext() { return new Uint8Array(this.raw.buffer, Offsets.ciphertext.start); }
-    encode() {
-        return this.raw;
-    }
-    toString() {
-        return (0, utils_1.decodeBase64)(this.raw);
-    }
-    toJSON() {
-        return {
-            version: this.version,
-            count: this.count,
-            previous: this.previous,
-            publicKey: (0, utils_1.decodeBase64)(this.publicKey),
-            nonce: (0, utils_1.decodeBase64)(this.nonce),
-            ciphertext: (0, utils_1.decodeBase64)(this.ciphertext)
-        };
-    }
-}
-exports.EncryptedDataConstructor = EncryptedDataConstructor;
-EncryptedDataConstructor.secretKeyLength = crypto_1.default.ECDH.secretKeyLength;
-EncryptedDataConstructor.publicKeyLength = crypto_1.default.ECDH.publicKeyLength;
-EncryptedDataConstructor.keyLength = crypto_1.default.box.keyLength;
-EncryptedDataConstructor.nonceLength = crypto_1.default.box.nonceLength;
-EncryptedDataConstructor.maxCount = 65536; //32768;
-EncryptedDataConstructor.countLength = 2;
-class Offsets {
-    static set(start, length) {
-        class Offset {
-            constructor(start, length) {
-                this.start = start;
-                this.length = length;
-                if (typeof length === 'number')
-                    this.end = start + length;
-            }
-            get get() {
-                return [this.start, this.length];
-            }
-        }
-        return new Offset(start, length);
-    }
-}
-Offsets.checksum = Offsets.set(0, 0);
-Offsets.version = Offsets.set(Offsets.checksum.end, 1);
-Offsets.count = Offsets.set(Offsets.version.end, EncryptedDataConstructor.countLength);
-Offsets.previous = Offsets.set(Offsets.count.end, EncryptedDataConstructor.countLength);
-Offsets.publicKey = Offsets.set(Offsets.previous.end, EncryptedDataConstructor.publicKeyLength);
-Offsets.nonce = Offsets.set(Offsets.publicKey.end, EncryptedDataConstructor.nonceLength);
-Offsets.ciphertext = Offsets.set(Offsets.nonce.end, undefined);
-var DataType;
-(function (DataType) {
-    DataType[DataType["UKNOWN"] = -1] = "UKNOWN";
-    DataType[DataType["RAW"] = 0] = "RAW";
-    DataType[DataType["NUMBER"] = 1] = "NUMBER";
-    DataType[DataType["STRING"] = 2] = "STRING";
-    DataType[DataType["ARRAY"] = 3] = "ARRAY";
-    DataType[DataType["OBJECT"] = 4] = "OBJECT";
-})(DataType || (DataType = {}));
-(function (DataType) {
-    function getType(type) {
-        return Object.values(DataType).indexOf(type.toLocaleUpperCase());
-    }
-    DataType.getType = getType;
-    function getName(type) {
-        return DataType[type].toLowerCase();
-    }
-    DataType.getName = getName;
-    function from(data) {
-        if (data instanceof Uint8Array)
-            return DataType.RAW;
-        return getType(typeof data);
-    }
-    DataType.from = from;
-})(DataType || (DataType = {}));
-class DataEncoder {
-    constructor(data) {
-        this.data = data;
-        this.type = DataType.getName(DataType.from(this.data));
-    }
-    get _type() {
-        return DataType.getType(this.type);
-    }
-    encode() {
-        let data;
-        switch (this._type) {
-            case DataType.RAW:
-                data = this.data;
-                break;
-            case DataType.NUMBER:
-                data = (0, utils_1.numberToArray)(this._type);
-                break;
-            case DataType.STRING:
-                data = (0, utils_1.encodeUTF8)(this.data);
-                break;
-            case DataType.ARRAY:
-                data = (0, utils_1.concatArrays)(...Array.from(this.data).flatMap(value => {
-                    const data = new DataEncoder(value).encode();
-                    return [(0, utils_1.numberToArray)(data.length, 8), data];
-                }));
-                break;
-            case DataType.OBJECT:
-                data = (0, utils_1.encodeJSON)(this.data);
-                break;
-            default:
-                throw new Error("Uknown type");
-        }
-        return (0, utils_1.concatArrays)((0, utils_1.numberToArray)(this._type), data);
-    }
-    toString() {
-        return "[Object XFreeSignalData]";
-    }
-    toJSON() {
-        return this.data;
-    }
-    static from(array) {
-        const type = array[0];
-        let rawData = array.subarray(1), data;
-        switch (type) {
-            case DataType.RAW:
-                data = rawData;
-                break;
-            case DataType.NUMBER:
-                data = (0, utils_1.numberFromArray)(rawData);
-                break;
-            case DataType.STRING:
-                data = (0, utils_1.decodeUTF8)(rawData);
-                break;
-            case DataType.ARRAY:
-                const arrayData = [];
-                let offset = 0;
-                while (offset < rawData.length) {
-                    const length = rawData.subarray(offset, offset + 8);
-                    if (length.length < 8)
-                        throw new Error('Invalid data length');
-                    const messageLength = (0, utils_1.numberFromArray)(length);
-                    offset += 8;
-                    if (offset + messageLength > rawData.length) {
-                        throw new Error('Invalid data length');
-                    }
-                    arrayData.push(rawData.subarray(offset, offset + messageLength));
-                    offset += messageLength;
-                }
-                data = arrayData;
-                break;
-            case DataType.OBJECT:
-                data = (0, utils_1.decodeJSON)(rawData);
-                break;
-            default:
-                throw new Error('Invalid data format');
-        }
-        return new DataEncoder(data);
+class AsyncMap {
+    constructor(iterable) {
+        this.map = new Map(iterable);
+    }
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.map.set(key, value);
+            return;
+        });
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.map.get(key);
+        });
+    }
+    has(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.map.has(key);
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.map.delete(key);
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.map.clear();
+        });
+    }
+    entries() {
+        return Array.from(this.map.entries()).values();
     }
 }
-exports.DataEncoder = DataEncoder;
-var XFreeSignal;
-(function (XFreeSignal) {
-    XFreeSignal.MIME = "application/x-freesignal";
-    XFreeSignal.version = 1;
-    function encodeBody(type, data, compressed = false) {
-        return new Body(type, data).encode(compressed);
-    }
-    XFreeSignal.encodeBody = encodeBody;
-    function decodeBody(body) {
-        return Body.from(body);
-    }
-    XFreeSignal.decodeBody = decodeBody;
-    let BodyType;
-    (function (BodyType) {
-        BodyType[BodyType["DATA"] = 0] = "DATA";
-        BodyType[BodyType["ERROR"] = 1] = "ERROR";
-    })(BodyType || (BodyType = {}));
-    (function (BodyType) {
-        function getName(type) {
-            return BodyType[type].toLowerCase();
-        }
-        BodyType.getName = getName;
-    })(BodyType || (BodyType = {}));
-    class Body {
-        constructor(type, data) {
-            this.type = type;
-            this.data = data;
-        }
-        encode(compressed = false) {
-            const data = new DataEncoder(this.data).encode();
-            return (0, utils_1.concatArrays)((0, utils_1.numberToArray)(((this.type === 'data' ? BodyType.DATA : BodyType.ERROR) << 6)
-                + (compressed ? 32 : 0)
-                + XFreeSignal.version), compressed ? fflate_1.default.deflateSync(data) : data);
-        }
-        toString() {
-            return "[Object XFreeSignalBody]";
-        }
-        toJSON() {
-            return {
-                type: this.type,
-                data: this.data
-            };
-        }
-        static from(array) {
-            return new Body(BodyType.getName((array[0] & 64) >> 6), DataEncoder.from((array[0] & 32) >> 5 === 1 ? fflate_1.default.inflateSync(array.subarray(1)) : array.subarray(1)).data);
-        }
-    }
-})(XFreeSignal || (exports.XFreeSignal = XFreeSignal = {}));
+exports.AsyncMap = AsyncMap;