lox-airplay-sender 0.1.0

package/dist/esm/core/srp.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bigInt = require('big-integer');
+const sha1 = require('js-sha1');
+const memoize = require('lodash/memoize');
+const util_1 = require("../utils/util");
+// ...
+const groups = {
+    1024: {
+        N: new bigInt('EEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C' +
+            '9C256576D674DF7496EA81D3383B4813D692C6E0E0D5D8E250B98BE4' +
+            '8E495C1D6089DAD15DC7D7B46154D6B6CE8EF4AD69B15D4982559B29' +
+            '7BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA9A' +
+            'FD5138FE8376435B9FC61D2FC0EB06E3', 16),
+        g: new bigInt(2)
+    },
+    2048: {
+        N: new bigInt('AC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC319294' +
+            '3DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310D' +
+            'CD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FB' +
+            'D5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF74' +
+            '7359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A' +
+            '436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D' +
+            '5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E73' +
+            '03CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB6' +
+            '94B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F' +
+            '9E4AFF73', 16),
+        g: new bigInt(2)
+    }
+};
+// ...
+class SRP {
+    group;
+    N;
+    g;
+    constructor(group) {
+        this.group = group;
+        const groupConfig = groups[group];
+        if (!groupConfig) {
+            throw new Error(`SRP group ${group} is not supported`);
+        }
+        this.N = groupConfig.N;
+        this.g = groupConfig.g;
+        this.A = memoize(this.A.bind(this));
+        this.K = memoize(this.K.bind(this));
+    }
+    // ...
+    // Private.
+    u(A, B) {
+        const A_buf = (0, util_1.hexString2ArrayBuffer)(A);
+        const B_buf = (0, util_1.hexString2ArrayBuffer)(B);
+        const result = new Uint8Array(A_buf.byteLength + B_buf.byteLength);
+        result.set(A_buf);
+        result.set(B_buf, A_buf.byteLength);
+        return sha1(result);
+    }
+    k() {
+        const padded_g = '0'.repeat((this.group / 4) - 1) + this.g.toString(16);
+        const N_buf = (0, util_1.hexString2ArrayBuffer)(this.N.toString(16));
+        const g_buf = (0, util_1.hexString2ArrayBuffer)(padded_g);
+        const result = new Uint8Array(N_buf.byteLength + g_buf.byteLength);
+        result.set(N_buf);
+        result.set(g_buf, N_buf.byteLength);
+        return sha1(result);
+    }
+    x(I, P, s) {
+        const s_buf = (0, util_1.hexString2ArrayBuffer)(s.toLowerCase());
+        const I_P_buf = (0, util_1.hexString2ArrayBuffer)(sha1(I + ':' + P));
+        const result = new Uint8Array(s_buf.byteLength + I_P_buf.byteLength);
+        result.set(s_buf);
+        result.set(I_P_buf, s_buf.byteLength);
+        return sha1(result);
+    }
+    ;
+    S(B, k, x, a, u) {
+        const Bn = new bigInt(B, 16);
+        const kn = new bigInt(k, 16);
+        const xn = new bigInt(x, 16);
+        const an = new bigInt(a, 16);
+        const un = new bigInt(u, 16);
+        return Bn.add(this.N.multiply(kn)).subtract(this.g.modPow(xn, this.N).multiply(kn)).mod(this.N)
+            .modPow(an.add(un.multiply(xn)), this.N)
+            .toString(16);
+    }
+    // ...
+    // Public.
+    A(a) {
+        return this.g.modPow(new bigInt(a, 16), this.N).toString(16);
+    }
+    K(I, P, s, a, B) {
+        const k = this.k();
+        const x = this.x(I, P, s);
+        const u = this.u(this.A(a), B);
+        const S = this.S(B, k, x, a, u);
+        // ...
+        const S_buf = (0, util_1.hexString2ArrayBuffer)(S);
+        let hash1 = new Uint8Array(S_buf.byteLength + 4);
+        hash1.set(S_buf);
+        hash1.set([0x00, 0x00, 0x00, 0x00], S_buf.byteLength);
+        let hash2 = new Uint8Array(S_buf.byteLength + 4);
+        hash2.set(S_buf);
+        hash2.set([0x00, 0x00, 0x00, 0x01], S_buf.byteLength);
+        return sha1(hash1) + sha1(hash2);
+    }
+    M1(I, P, s, a, B) {
+        // M1 = H( H(N) ^ H(g) | H(I) | s | PAD(A) | PAD(B) | K )
+        const A = this.A(a);
+        const K = this.K(I, P, s, a, B);
+        const hN = new Uint8Array(sha1.arrayBuffer((0, util_1.hexString2ArrayBuffer)(this.N.toString(16))));
+        const hg = new Uint8Array(sha1.arrayBuffer([this.g.toString(16)]));
+        const hN_hg = new Uint8Array(20);
+        for (let i = 0; i < 20; i++) {
+            hN_hg[i] = hN[i] ^ hg[i];
+        }
+        const hI = sha1.arrayBuffer(I);
+        // ...
+        return sha1.create()
+            .update(hN_hg)
+            .update(hI)
+            .update((0, util_1.hexString2ArrayBuffer)(s))
+            .update((0, util_1.hexString2ArrayBuffer)(A))
+            .update((0, util_1.hexString2ArrayBuffer)(B))
+            .update((0, util_1.hexString2ArrayBuffer)(K))
+            .hex();
+    }
+}
+// ...
+exports.default = SRP;

package/dist/esm/core/udpServers.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_dgram_1 = __importDefault(require("node:dgram"));
+const node_events_1 = require("node:events");
+const async_1 = __importDefault(require("async"));
+const config_1 = __importDefault(require("../utils/config"));
+const numUtil_1 = require("../utils/numUtil");
+const ntp_1 = __importDefault(require("../utils/ntp"));
+const UNBOUND = 0;
+const BINDING = 1;
+const BOUND = 2;
+/**
+ * Manages control/timing UDP sockets used by RAOP for resend requests and clock sync.
+ * Binds ports for both endpoints and emits events with socket info.
+ */
+class UDPServers extends node_events_1.EventEmitter {
+    status = UNBOUND;
+    control = { socket: null, port: null, name: 'control' };
+    timing = { socket: null, port: null, name: 'timing' };
+    hosts = [];
+    /**
+     * Bind control + timing sockets for a host and emit `ports` when ready.
+     */
+    bind(host) {
+        this.hosts.push(host);
+        if (this.status === BOUND) {
+            process.nextTick(() => {
+                this.emit('ports', null, this.control, this.timing);
+            });
+            return;
+        }
+        if (this.status === BINDING) {
+            return;
+        }
+        this.status = BINDING;
+        this.timing.socket = node_dgram_1.default.createSocket({ type: 'udp4', reuseAddr: true });
+        this.timing.socket.on('message', (msg, rinfo) => {
+            if (!this.hosts.includes(rinfo.address))
+                return;
+            const ts1 = msg.readUInt32BE(24);
+            const ts2 = msg.readUInt32BE(28);
+            const reply = Buffer.alloc(32);
+            reply.writeUInt16BE(0x80d3, 0);
+            reply.writeUInt16BE(0x0007, 2);
+            reply.writeUInt32BE(0x00000000, 4);
+            reply.writeUInt32BE(ts1, 8);
+            reply.writeUInt32BE(ts2, 12);
+            const ntpTime = ntp_1.default.timestamp();
+            ntpTime.copy(reply, 16);
+            ntpTime.copy(reply, 24);
+            this.timing.socket?.send(reply, 0, reply.length, rinfo.port, rinfo.address);
+        });
+        this.control.socket = node_dgram_1.default.createSocket({ type: 'udp4', reuseAddr: true });
+        this.control.socket.on('message', (msg, rinfo) => {
+            if (!this.hosts.includes(rinfo.address))
+                return;
+            const resendRequested = msg.readUInt8(1) === (0x80 | 0x55);
+            if (resendRequested) {
+                const missedSeq = msg.readUInt16BE(4);
+                const count = msg.readUInt16BE(6);
+                this.emit('resendRequested', missedSeq, count);
+            }
+        });
+        if (process.platform !== 'darwin') {
+            this.control.socket.on('error', (err) => {
+                this.emit('ports', err);
+            });
+            this.timing.socket.on('error', (err) => {
+                this.emit('ports', err);
+            });
+            this.control.socket.bind(0, () => {
+                this.control.port = this.control.socket?.address().port ?? null;
+            });
+            this.timing.socket.bind(0, () => {
+                this.timing.port = this.timing.socket?.address().port ?? null;
+            });
+            const interval = setInterval(() => {
+                if (this.timing.port != null && this.control.port != null) {
+                    clearInterval(interval);
+                    this.status = BOUND;
+                    this.emit('ports', null, this.control, this.timing);
+                }
+            }, 100);
+            return;
+        }
+        const toBind = [this.control, this.timing];
+        let currentPort = config_1.default.udp_default_port;
+        async_1.default.whilst((cb) => cb(null, toBind.length > 0), (cb) => {
+            const nextPort = toBind[0];
+            nextPort.socket?.once('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    currentPort += 1;
+                    cb();
+                }
+                else {
+                    cb(err);
+                }
+            });
+            nextPort.socket?.once('listening', () => {
+                toBind.shift();
+                nextPort.port = currentPort;
+                currentPort += 1;
+                cb();
+            });
+            nextPort.socket?.bind(currentPort);
+        }, (err) => {
+            if (err) {
+                this.close();
+                this.emit('ports', err);
+            }
+            else {
+                this.status = BOUND;
+                this.emit('ports', null, this.control, this.timing);
+            }
+        });
+    }
+    /** Close sockets and reset state. */
+    close() {
+        try {
+            this.status = UNBOUND;
+            this.timing.socket?.close();
+            this.timing.socket = null;
+            this.control.socket?.close();
+            this.control.socket = null;
+        }
+        catch {
+            // ignore
+        }
+    }
+    /**
+     * Send an RTCP sync packet to a receiver to align playback.
+     */
+    sendControlSync(seq, dev) {
+        if (this.status !== BOUND || !this.control.socket)
+            return;
+        const packet = Buffer.alloc(20);
+        packet.writeUInt16BE(0x80d4, 0);
+        packet.writeUInt16BE(0x0007, 2);
+        packet.writeUInt32BE((0, numUtil_1.low32)(seq * config_1.default.frames_per_packet), 4);
+        const ntpTime = ntp_1.default.timestamp();
+        ntpTime.copy(packet, 8);
+        packet.writeUInt32BE((0, numUtil_1.low32)(seq * config_1.default.frames_per_packet + config_1.default.sampling_rate * 2), 16);
+        this.control.socket.send(packet, 0, packet.length, dev.controlPort, dev.host);
+    }
+}
+exports.default = UDPServers;

package/dist/esm/homekit/credentials.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Credentials = void 0;
+const encryption_1 = __importDefault(require("./encryption"));
+const struct = require('python-struct');
+/**
+ * Holds and serializes HomeKit credential blobs used during AirPlay 2 auth.
+ */
+class Credentials {
+    uniqueIdentifier;
+    identifier;
+    pairingId;
+    publicKey;
+    encryptionKey;
+    encryptCount;
+    decryptCount;
+    writeKey;
+    readKey;
+    constructor(uniqueIdentifier, identifier, pairingId, publicKey, encryptionKey) {
+        this.uniqueIdentifier = uniqueIdentifier;
+        this.identifier = identifier;
+        this.pairingId = pairingId;
+        this.publicKey = publicKey;
+        this.encryptionKey = encryptionKey;
+        this.encryptCount = 0;
+        this.decryptCount = 0;
+        this.writeKey = encryptionKey;
+        this.readKey = encryptionKey;
+    }
+    /**
+    * Parse a credentials string into a Credentials object.
+    * @param text  The credentials string.
+    * @returns A credentials object.
+    */
+    static parse(text) {
+        const parts = text.split(':');
+        return new Credentials(parts[0], Buffer.from(parts[1], 'hex'), Buffer.from(parts[2], 'hex').toString(), Buffer.from(parts[3], 'hex'), Buffer.from(parts[4], 'hex'));
+    }
+    /**
+    * Returns a string representation of a Credentials object.
+    * @returns A string representation of a Credentials object.
+    */
+    toString() {
+        return this.uniqueIdentifier
+            + ":"
+            + this.identifier.toString('hex')
+            + ":"
+            + Buffer.from(this.pairingId).toString('hex')
+            + ":"
+            + this.publicKey.toString('hex')
+            + ":"
+            + this.encryptionKey.toString('hex');
+    }
+    encrypt(message) {
+        let offset = 0;
+        const total = message.byteLength;
+        let result = Buffer.concat([]);
+        while (offset < total) {
+            const length = Math.min(total - offset, 1024);
+            const s1lengthBytes = struct.pack("H", length);
+            // let cipher = crypto.createCipheriv('chacha20-poly1305', this.writeKey, Buffer.concat([Buffer.from([0x00,0x00,0x00,0x00]),struct.pack("Q", this.decryptCount)]), { authTagLength: 16 });
+            // cipher.setAAD(s1length_bytes);
+            // let s1ct = cipher.update(message);
+            // cipher.final();
+            // let s1tag = encryption_1.default.computePoly1305(s1ct,s1length_bytes,Buffer.concat([Buffer.from([0x00,0x00,0x00,0x00]),struct.pack("Q", this.decryptCount)]),this.writeKey)
+            const [s1ct, s1tag] = encryption_1.default.encryptAndSeal(message.slice(offset, offset + length), s1lengthBytes, Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), struct.pack("Q", this.encryptCount)]), this.writeKey);
+            const ciphertext = Buffer.concat([s1lengthBytes, s1ct, s1tag]);
+            offset += length;
+            this.encryptCount += 1;
+            result = Buffer.concat([result, ciphertext]);
+        }
+        return result;
+    }
+    decrypt(message) {
+        let offset = 0;
+        let result = Buffer.concat([]);
+        while (offset < message.byteLength) {
+            const lengthBytes = message.slice(offset, offset + 2);
+            const length = struct.unpack("H", lengthBytes);
+            const messagea = message.slice(offset + 2, offset + 2 + length[0] + 16);
+            const cipherText = messagea.slice(0, -16);
+            const hmac = messagea.slice(-16);
+            const decrypted = encryption_1.default.verifyAndDecrypt(cipherText, hmac, lengthBytes, Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), struct.pack("Q", this.decryptCount)]), this.readKey);
+            this.decryptCount += 1;
+            offset = offset + length[0] + 16 + 2;
+            result = Buffer.concat([result, decrypted ?? Buffer.alloc(0)]);
+        }
+        return result;
+    }
+    encryptAudio(message, aad, nonce) {
+        return Buffer.concat([
+            Buffer.concat(encryption_1.default.encryptAndSeal(message, aad, struct.pack("Q", nonce), this.writeKey)),
+            Buffer.from(struct.pack("Q", nonce)),
+        ]);
+    }
+}
+exports.Credentials = Credentials;

package/dist/esm/homekit/encryption.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * AirPlay 2/HomeKit encryption helpers (ChaCha20-Poly1305 + HKDF) ported from node_airtunes2.
+ */
+// i'd really prefer for this to be a direct call to
+// Sodium.crypto_aead_chacha20poly1305_decrypt()
+// but unfortunately the way it constructs the message to
+// calculate the HMAC is not compatible with homekit
+// (long story short, it uses [ AAD, AAD.length, CipherText, CipherText.length ]
+// whereas homekit expects [ AAD, CipherText, AAD.length, CipherText.length ]
+function verifyAndDecrypt(cipherText, mac, AAD, nonce, key) {
+    try {
+        let nonceBuf = nonce;
+        if (nonceBuf.byteLength === 8) {
+            nonceBuf = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), nonceBuf]);
+        }
+        const decipher = crypto_1.default.createDecipheriv('chacha20-poly1305', key, nonceBuf, { authTagLength: 16 });
+        if (AAD != null) {
+            decipher.setAAD(AAD); // must be called before data
+        }
+        decipher.setAuthTag(mac);
+        const decrypted = Buffer.concat([decipher.update(cipherText), decipher.final()]);
+        return decrypted;
+    }
+    catch (error) {
+        return null;
+    }
+}
+function encryptAndSeal(plainText, AAD, nonce, key) {
+    let nonceBuf = nonce;
+    if (nonceBuf.byteLength === 8) {
+        nonceBuf = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), nonceBuf]);
+    }
+    const cipher = crypto_1.default.createCipheriv('chacha20-poly1305', key, nonceBuf, { authTagLength: 16 });
+    if (AAD != null) {
+        cipher.setAAD(AAD); // must be called before data
+    }
+    const cipherText = Buffer.concat([cipher.update(plainText), cipher.final()]);
+    const hmac = cipher.getAuthTag();
+    return [cipherText, hmac];
+}
+// function getPadding(buffer, blockSize) {
+//     return buffer.length % blockSize === 0
+//         ? Buffer.alloc(0)
+//         : Buffer.alloc(blockSize - (buffer.length % blockSize));
+// }
+function HKDF(hashAlg, salt, ikm, info, size) {
+    // create the hash alg to see if it exists and get its length
+    const hash = crypto_1.default.createHash(hashAlg);
+    const hashLength = hash.digest().length;
+    // now we compute the PRK
+    const hmac = crypto_1.default.createHmac(hashAlg, salt);
+    hmac.update(ikm);
+    const prk = hmac.digest();
+    let prev = Buffer.alloc(0);
+    const buffers = [];
+    const numBlocks = Math.ceil(size / hashLength);
+    const infoBuf = Buffer.from(info);
+    for (let i = 0; i < numBlocks; i++) {
+        const roundHmac = crypto_1.default.createHmac(hashAlg, prk);
+        const input = Buffer.concat([
+            prev,
+            infoBuf,
+            Buffer.from(String.fromCharCode(i + 1)),
+        ]);
+        roundHmac.update(input);
+        prev = roundHmac.digest();
+        buffers.push(prev);
+    }
+    const output = Buffer.concat(buffers, size);
+    return output.slice(0, size);
+}
+exports.default = {
+    encryptAndSeal,
+    verifyAndDecrypt,
+    HKDF,
+};

package/dist/esm/homekit/number.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+/*
+ * Originally based on code from github:KhaosT/HAP-NodeJS@0c8fd88 used
+ * used per the terms of the Apache Software License v2.
+ *
+ * Original code copyright Khaos Tian <khaos.tian@gmail.com>
+ *
+ * Modifications copyright Zach Bean <zb@forty2.com>
+ *  * Reformatted for ES6-style module
+ *  * renamed *UInt64* to *UInt53* to be more clear about range
+ *  * renamed uintHighLow to be more clear about what it does
+ *  * Refactored to return a buffer rather write into a passed-in buffer
+ */
+function splitUInt53(value) {
+    const MAX_UINT32 = 0x00000000ffffffff;
+    const MAX_INT53 = 0x001fffffffffffff;
+    (0, assert_1.default)(value > -1 && value <= MAX_INT53, 'number out of range');
+    (0, assert_1.default)(Math.floor(value) === value, 'number must be an integer');
+    let high = 0;
+    const signbit = value & 0xffffffff;
+    const low = signbit < 0 ? (value & 0x7fffffff) + 0x80000000 : signbit;
+    if (value > MAX_UINT32) {
+        high = (value - low) / (MAX_UINT32 + 1);
+    }
+    return [high, low];
+}
+function UInt53toBufferLE(value) {
+    const [high, low] = splitUInt53(value);
+    const buf = Buffer.alloc(8);
+    buf.writeUInt32LE(low, 0);
+    buf.writeUInt32LE(high, 4);
+    return buf;
+}
+function UInt16toBufferBE(value) {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16BE(value, 0);
+    return buf;
+}
+exports.default = {
+    UInt53toBufferLE,
+    UInt16toBufferBE,
+};

package/dist/esm/homekit/tlv.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Type Length Value encoding/decoding, used by HAP as a wire format.
+ * https://en.wikipedia.org/wiki/Type-length-value
+ */
+const Tag = {
+    PairingMethod: 0x00,
+    Username: 0x01,
+    Salt: 0x02,
+    // could be either the SRP client public key (384 bytes) or the ED25519 public key (32 bytes), depending on context
+    PublicKey: 0x03,
+    Proof: 0x04,
+    EncryptedData: 0x05,
+    Sequence: 0x06,
+    ErrorCode: 0x07,
+    BackOff: 0x08,
+    Signature: 0x0a,
+    MFiCertificate: 0x09,
+    MFiSignature: 0x0a,
+    Flags: 0x13,
+};
+function encodeOne(type, data) {
+    let bufferData;
+    if (typeof data === 'number') {
+        bufferData = Buffer.from([data]);
+    }
+    else if (typeof data === 'string') {
+        bufferData = Buffer.from(data);
+    }
+    else {
+        bufferData = data;
+    }
+    if (bufferData.length <= 255) {
+        return Buffer.concat([Buffer.from([type, bufferData.length]), bufferData]);
+    }
+    let leftLength = bufferData.length;
+    let tempBuffer = Buffer.alloc(0);
+    let currentStart = 0;
+    for (; leftLength > 0;) {
+        if (leftLength >= 255) {
+            tempBuffer = Buffer.concat([
+                tempBuffer,
+                Buffer.from([type, 0xff]),
+                bufferData.slice(currentStart, currentStart + 255),
+            ]);
+            leftLength -= 255;
+            currentStart += 255;
+        }
+        else {
+            tempBuffer = Buffer.concat([
+                tempBuffer,
+                Buffer.from([type, leftLength]),
+                bufferData.slice(currentStart, currentStart + leftLength),
+            ]);
+            leftLength = 0;
+        }
+    }
+    return tempBuffer;
+}
+function encode(type, data, ...args) {
+    const encodedTLVBuffer = encodeOne(type, data);
+    if (args.length === 0) {
+        return encodedTLVBuffer;
+    }
+    const nextType = args[0];
+    const nextData = args[1];
+    const remaining = args.slice(2);
+    const remainingTLVBuffer = encode(nextType, nextData, ...remaining);
+    return Buffer.concat([encodedTLVBuffer, remainingTLVBuffer]);
+}
+function decode(data) {
+    const objects = {};
+    let leftLength = data.length;
+    let currentIndex = 0;
+    for (; leftLength > 0;) {
+        const type = data[currentIndex];
+        const length = data[currentIndex + 1];
+        currentIndex += 2;
+        leftLength -= 2;
+        const newData = data.slice(currentIndex, currentIndex + length);
+        if (objects[type]) {
+            objects[type] = Buffer.concat([objects[type], newData]);
+        }
+        else {
+            objects[type] = newData;
+        }
+        currentIndex += length;
+        leftLength -= length;
+    }
+    return objects;
+}
+exports.default = {
+    Tag,
+    encode,
+    decode,
+};