hap-nodejs 0.12.3-beta.27 → 0.12.3-beta.28

package/dist/lib/datastream/DataStreamServer.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataStreamConnection = exports.HDSConnectionError = exports.HDSConnectionErrorType = exports.DataStreamConnectionEvent = exports.DataStreamServer = exports.DataStreamServerEvent = exports.MessageType = exports.HDSProtocolError = exports.HDSProtocolSpecificErrorReason = exports.HDSStatus = exports.Topics = exports.Protocols = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const crypto_1 = tslib_1.__importDefault(require("crypto"));
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const events_1 = require("events");
-const net_1 = tslib_1.__importDefault(require("net"));
-const hapCrypto = tslib_1.__importStar(require("../util/hapCrypto"));
-const DataStreamParser_1 = require("./DataStreamParser");
-const debug = (0, debug_1.default)("HAP-NodeJS:DataStream:Server");
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var crypto_1 = tslib_1.__importDefault(require("crypto"));
+var debug_1 = tslib_1.__importDefault(require("debug"));
+var events_1 = require("events");
+var net_1 = tslib_1.__importDefault(require("net"));
+var hapCrypto = tslib_1.__importStar(require("../util/hapCrypto"));
+var DataStreamParser_1 = require("./DataStreamParser");
+var debug = (0, debug_1.default)("HAP-NodeJS:DataStream:Server");
 /**
  * @group HomeKit Data Streams (HDS)
  */
@@ -70,19 +70,21 @@ var HDSProtocolSpecificErrorReason;
  * E.g. it may be used to encode a {@link HDSStatus.PROTOCOL_SPECIFIC_ERROR} in the {@link Protocols.DATA_SEND} protocol.
  * @group HomeKit Data Streams (HDS)
  */
-class HDSProtocolError extends Error {
-    reason;
+var HDSProtocolError = /** @class */ (function (_super) {
+    tslib_1.__extends(HDSProtocolError, _super);
     /**
      * Initializes a new `HDSProtocolError`
      * @param reason - The {@link HDSProtocolSpecificErrorReason}.
      *  Values MUST NOT be {@link HDSProtocolSpecificErrorReason.NORMAL}.
      */
-    constructor(reason) {
-        super("HDSProtocolError: " + reason);
+    function HDSProtocolError(reason) {
+        var _this = _super.call(this, "HDSProtocolError: " + reason) || this;
         (0, assert_1.default)(reason !== 0 /* HDSProtocolSpecificErrorReason.NORMAL */, "Cannot initialize a HDSProtocolError with NORMAL!");
-        this.reason = reason;
+        _this.reason = reason;
+        return _this;
     }
-}
+    return HDSProtocolError;
+}(Error));
 exports.HDSProtocolError = HDSProtocolError;
 var ServerState;
 (function (ServerState) {
@@ -128,19 +130,16 @@ var DataStreamServerEvent;
  * @group HomeKit Data Streams (HDS)
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-class DataStreamServer extends events_1.EventEmitter {
-    static version = "1.0";
-    state = 0 /* ServerState.UNINITIALIZED */;
-    static accessoryToControllerInfo = Buffer.from("HDS-Read-Encryption-Key");
-    static controllerToAccessoryInfo = Buffer.from("HDS-Write-Encryption-Key");
-    tcpServer;
-    tcpPort;
-    preparedSessions = [];
-    connections = [];
-    removeListenersOnceClosed = false;
-    internalEventEmitter = new events_1.EventEmitter(); // used for message event and message request handlers
-    constructor() {
-        super();
+var DataStreamServer = /** @class */ (function (_super) {
+    tslib_1.__extends(DataStreamServer, _super);
+    function DataStreamServer() {
+        var _this = _super.call(this) || this;
+        _this.state = 0 /* ServerState.UNINITIALIZED */;
+        _this.preparedSessions = [];
+        _this.connections = [];
+        _this.removeListenersOnceClosed = false;
+        _this.internalEventEmitter = new events_1.EventEmitter(); // used for message event and message request handlers
+        return _this;
     }
     /**
      * Registers a new event handler to handle incoming event messages.
@@ -151,10 +150,10 @@ class DataStreamServer extends events_1.EventEmitter {
      * @param event - name of the event (also referred to as topic. See {@link Topics} for some known ones)
      * @param handler - function to be called for every occurring event
      */
-    onEventMessage(protocol, event, handler) {
+    DataStreamServer.prototype.onEventMessage = function (protocol, event, handler) {
         this.internalEventEmitter.on(protocol + "-e-" + event, handler);
         return this;
-    }
+    };
     /**
      * Removes a registered event handler.
      *
@@ -162,10 +161,10 @@ class DataStreamServer extends events_1.EventEmitter {
      * @param event - name of the event (also referred to as topic. See {@link Topics} for some known ones)
      * @param handler - registered event handler
      */
-    removeEventHandler(protocol, event, handler) {
+    DataStreamServer.prototype.removeEventHandler = function (protocol, event, handler) {
         this.internalEventEmitter.removeListener(protocol + "-e-" + event, handler);
         return this;
-    }
+    };
     /**
      * Registers a new request handler to handle incoming request messages.
      * The handler is only called for a connection if for the give protocol no ProtocolHandler
@@ -175,10 +174,10 @@ class DataStreamServer extends events_1.EventEmitter {
      * @param request - name of the request (also referred to as topic. See {@link Topics} for some known ones)
      * @param handler - function to be called for every occurring request
      */
-    onRequestMessage(protocol, request, handler) {
+    DataStreamServer.prototype.onRequestMessage = function (protocol, request, handler) {
         this.internalEventEmitter.on(protocol + "-r-" + request, handler);
         return this;
-    }
+    };
     /**
      * Removes a registered request handler.
      *
@@ -186,26 +185,27 @@ class DataStreamServer extends events_1.EventEmitter {
      * @param request - name of the request (also referred to as topic. See {@link Topics} for some known ones)
      * @param handler - registered request handler
      */
-    removeRequestHandler(protocol, request, handler) {
+    DataStreamServer.prototype.removeRequestHandler = function (protocol, request, handler) {
         this.internalEventEmitter.removeListener(protocol + "-r-" + request, handler);
         return this;
-    }
-    prepareSession(connection, controllerKeySalt, callback) {
+    };
+    DataStreamServer.prototype.prepareSession = function (connection, controllerKeySalt, callback) {
+        var _this = this;
         debug("Preparing for incoming HDS connection from %s", connection.sessionID);
-        const accessoryKeySalt = crypto_1.default.randomBytes(32);
-        const salt = Buffer.concat([controllerKeySalt, accessoryKeySalt]);
-        const accessoryToControllerEncryptionKey = hapCrypto.HKDF("sha512", salt, connection.encryption.sharedSecret, DataStreamServer.accessoryToControllerInfo, 32);
-        const controllerToAccessoryEncryptionKey = hapCrypto.HKDF("sha512", salt, connection.encryption.sharedSecret, DataStreamServer.controllerToAccessoryInfo, 32);
-        const preparedSession = {
+        var accessoryKeySalt = crypto_1.default.randomBytes(32);
+        var salt = Buffer.concat([controllerKeySalt, accessoryKeySalt]);
+        var accessoryToControllerEncryptionKey = hapCrypto.HKDF("sha512", salt, connection.encryption.sharedSecret, DataStreamServer.accessoryToControllerInfo, 32);
+        var controllerToAccessoryEncryptionKey = hapCrypto.HKDF("sha512", salt, connection.encryption.sharedSecret, DataStreamServer.controllerToAccessoryInfo, 32);
+        var preparedSession = {
             connection: connection,
             accessoryToControllerEncryptionKey: accessoryToControllerEncryptionKey,
             controllerToAccessoryEncryptionKey: controllerToAccessoryEncryptionKey,
             accessoryKeySalt: accessoryKeySalt,
-            connectTimeout: setTimeout(() => this.timeoutPreparedSession(preparedSession), 10000),
+            connectTimeout: setTimeout(function () { return _this.timeoutPreparedSession(preparedSession); }, 10000),
         };
         preparedSession.connectTimeout.unref();
         this.preparedSessions.push(preparedSession);
-        this.checkTCPServerEstablished(preparedSession, (error) => {
+        this.checkTCPServerEstablished(preparedSession, function (error) {
             if (error) {
                 callback(error);
             }
@@ -213,16 +213,17 @@ class DataStreamServer extends events_1.EventEmitter {
                 callback(undefined, preparedSession);
             }
         });
-    }
-    timeoutPreparedSession(preparedSession) {
+    };
+    DataStreamServer.prototype.timeoutPreparedSession = function (preparedSession) {
         debug("Prepared HDS session timed out out since no connection was opened for 10 seconds (%s)", preparedSession.connection.sessionID);
-        const index = this.preparedSessions.indexOf(preparedSession);
+        var index = this.preparedSessions.indexOf(preparedSession);
         if (index >= 0) {
             this.preparedSessions.splice(index, 1);
         }
         this.checkCloseable();
-    }
-    checkTCPServerEstablished(preparedSession, callback) {
+    };
+    DataStreamServer.prototype.checkTCPServerEstablished = function (preparedSession, callback) {
+        var _this = this;
         switch (this.state) {
             case 0 /* ServerState.UNINITIALIZED */:
                 debug("Starting up TCP server.");
@@ -244,34 +245,34 @@ class DataStreamServer extends events_1.EventEmitter {
                 break;
             case 3 /* ServerState.CLOSING */:
                 debug("TCP socket is currently closing. Trying again when server is fully closed and opening a new one then.");
-                this.tcpServer.once("close", () => setTimeout(() => this.checkTCPServerEstablished(preparedSession, callback), 10));
+                this.tcpServer.once("close", function () { return setTimeout(function () { return _this.checkTCPServerEstablished(preparedSession, callback); }, 10); });
                 break;
         }
-    }
-    listening(preparedSession, callback) {
+    };
+    DataStreamServer.prototype.listening = function (preparedSession, callback) {
         this.state = 2 /* ServerState.LISTENING */;
-        const address = this.tcpServer.address();
+        var address = this.tcpServer.address();
         if (address && typeof address !== "string") { // address is only typeof string when listening to a pipe or unix socket
             this.tcpPort = address.port;
             preparedSession.port = address.port;
             debug("TCP server is now listening for new data stream connections on port %s", address.port);
             callback();
         }
-    }
-    onConnection(socket) {
+    };
+    DataStreamServer.prototype.onConnection = function (socket) {
         debug("[%s] New DataStream connection was established", socket.remoteAddress);
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        const connection = new DataStreamConnection(socket);
+        var connection = new DataStreamConnection(socket);
         connection.on("identification" /* DataStreamConnectionEvent.IDENTIFICATION */, this.handleSessionIdentification.bind(this, connection));
         connection.on("handle-message-globally" /* DataStreamConnectionEvent.HANDLE_MESSAGE_GLOBALLY */, this.handleMessageGlobally.bind(this, connection));
         connection.on("closed" /* DataStreamConnectionEvent.CLOSED */, this.connectionClosed.bind(this, connection));
         this.connections.push(connection);
         this.emit("connection-opened" /* DataStreamServerEvent.CONNECTION_OPENED */, connection);
-    }
-    handleSessionIdentification(connection, firstFrame, callback) {
-        let identifiedSession = undefined;
-        for (let i = 0; i < this.preparedSessions.length; i++) {
-            const preparedSession = this.preparedSessions[i];
+    };
+    DataStreamServer.prototype.handleSessionIdentification = function (connection, firstFrame, callback) {
+        var identifiedSession = undefined;
+        for (var i = 0; i < this.preparedSessions.length; i++) {
+            var preparedSession = this.preparedSessions[i];
             // if we successfully decrypt the first frame with this key we know to which session this connection belongs
             if (connection.decryptHDSFrame(firstFrame, preparedSession.controllerToAccessoryEncryptionKey)) {
                 identifiedSession = preparedSession;
@@ -281,7 +282,7 @@ class DataStreamServer extends events_1.EventEmitter {
         callback(identifiedSession);
         if (identifiedSession) {
             debug("[%s] Connection was successfully identified (linked with sessionId: %s)", connection.remoteAddress, identifiedSession.connection.sessionID);
-            const index = this.preparedSessions.indexOf(identifiedSession);
+            var index = this.preparedSessions.indexOf(identifiedSession);
             if (index >= 0) {
                 this.preparedSessions.splice(index, 1);
             }
@@ -295,11 +296,12 @@ class DataStreamServer extends events_1.EventEmitter {
             debug("[%s] Could not identify connection. Terminating.", connection.remoteAddress);
             connection.close(); // disconnecting since first message was not a valid hello
         }
-    }
-    handleMessageGlobally(connection, message) {
+    };
+    DataStreamServer.prototype.handleMessageGlobally = function (connection, message) {
+        var _a;
         assert_1.default.notStrictEqual(message.type, 3 /* MessageType.RESPONSE */); // responses can't physically get here
-        let separator = "";
-        const args = [];
+        var separator = "";
+        var args = [];
         if (message.type === 1 /* MessageType.EVENT */) {
             separator = "-e-";
         }
@@ -308,9 +310,9 @@ class DataStreamServer extends events_1.EventEmitter {
             args.push(message.id);
         }
         args.push(message.message);
-        let hadListeners;
+        var hadListeners;
         try {
-            hadListeners = this.internalEventEmitter.emit(message.protocol + separator + message.topic, connection, ...args);
+            hadListeners = (_a = this.internalEventEmitter).emit.apply(_a, tslib_1.__spreadArray([message.protocol + separator + message.topic, connection], tslib_1.__read(args), false));
         }
         catch (error) {
             hadListeners = true;
@@ -320,8 +322,8 @@ class DataStreamServer extends events_1.EventEmitter {
         if (!hadListeners) {
             debug("[%s] WARNING no handler was found for message: %o", connection.remoteAddress, message);
         }
-    }
-    connectionClosed(connection) {
+    };
+    DataStreamServer.prototype.connectionClosed = function (connection) {
         debug("[%s] DataStream connection closed", connection.remoteAddress);
         this.connections.splice(this.connections.indexOf(connection), 1);
         this.emit("connection-closed" /* DataStreamServerEvent.CONNECTION_CLOSED */, connection);
@@ -329,34 +331,49 @@ class DataStreamServer extends events_1.EventEmitter {
         if (this.state === 3 /* ServerState.CLOSING */ && this.removeListenersOnceClosed && this.connections.length === 0) {
             this.removeAllListeners(); // see this.destroy()
         }
-    }
-    checkCloseable() {
+    };
+    DataStreamServer.prototype.checkCloseable = function () {
         if (this.connections.length === 0 && this.preparedSessions.length === 0 && this.state < 3 /* ServerState.CLOSING */) {
             debug("Last connection disconnected. Closing the server now.");
             this.state = 3 /* ServerState.CLOSING */;
             this.tcpServer.close();
         }
-    }
+    };
     /**
      * This method will fully stop the DataStreamServer
      */
-    destroy() {
+    DataStreamServer.prototype.destroy = function () {
+        var e_1, _a;
         if (this.state > 0 /* ServerState.UNINITIALIZED */ && this.state < 3 /* ServerState.CLOSING */) {
             this.tcpServer.close();
-            for (const connection of this.connections) {
-                connection.close();
+            try {
+                for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var connection = _c.value;
+                    connection.close();
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
         }
         this.state = 3 /* ServerState.CLOSING */;
         this.removeListenersOnceClosed = true;
         this.internalEventEmitter.removeAllListeners();
-    }
-    closed() {
+    };
+    DataStreamServer.prototype.closed = function () {
         this.tcpServer = undefined;
         this.tcpPort = undefined;
         this.state = 0 /* ServerState.UNINITIALIZED */;
-    }
-}
+    };
+    DataStreamServer.version = "1.0";
+    DataStreamServer.accessoryToControllerInfo = Buffer.from("HDS-Read-Encryption-Key");
+    DataStreamServer.controllerToAccessoryInfo = Buffer.from("HDS-Write-Encryption-Key");
+    return DataStreamServer;
+}(events_1.EventEmitter));
 exports.DataStreamServer = DataStreamServer;
 /**
  * @group HomeKit Data Streams (HDS)
@@ -391,13 +408,15 @@ var HDSConnectionErrorType;
 /**
  * @group HomeKit Data Streams (HDS)
  */
-class HDSConnectionError extends Error {
-    type;
-    constructor(message, type) {
-        super(message);
-        this.type = type;
-    }
-}
+var HDSConnectionError = /** @class */ (function (_super) {
+    tslib_1.__extends(HDSConnectionError, _super);
+    function HDSConnectionError(message, type) {
+        var _this = _super.call(this, message) || this;
+        _this.type = type;
+        return _this;
+    }
+    return HDSConnectionError;
+}(Error));
 exports.HDSConnectionError = HDSConnectionError;
 /**
  * DataStream connection which holds any necessary state information, encryption and decryption keys, manages
@@ -406,69 +425,59 @@ exports.HDSConnectionError = HDSConnectionError;
  * @group HomeKit Data Streams (HDS)
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-class DataStreamConnection extends events_1.EventEmitter {
-    static MAX_PAYLOAD_LENGTH = 0b11111111111111111111;
-    socket;
-    connection; // reference to the hap connection. is present when state > UNIDENTIFIED
-    remoteAddress;
-    /*
-          Since our DataStream server does only listen on one port and this port is supplied to every client
-          which wants to connect, we do not really know which client is who when we receive a tcp connection.
-          Thus, we find the correct PreparedDataStreamSession object by testing the encryption keys of all available
-          prepared sessions. Then we can reference this hds connection with the correct hap connection and mark it as identified.
-       */
-    state = 0 /* ConnectionState.UNIDENTIFIED */;
-    accessoryToControllerEncryptionKey;
-    controllerToAccessoryEncryptionKey;
-    accessoryToControllerNonce;
-    accessoryToControllerNonceBuffer;
-    controllerToAccessoryNonce;
-    controllerToAccessoryNonceBuffer;
-    frameBuffer; // used to store incomplete HDS frames
-    hapConnectionClosedListener;
-    protocolHandlers = {}; // used to store protocolHandlers identified by their protocol name
-    responseHandlers = {}; // used to store responseHandlers indexed by their respective requestId
-    responseTimers = {}; // used to store response timeouts indexed by their respective requestId
-    helloTimer;
-    constructor(socket) {
-        super();
-        this.socket = socket;
-        this.remoteAddress = socket.remoteAddress;
-        this.socket.setNoDelay(true); // disable Nagle algorithm
-        this.socket.setKeepAlive(true);
-        this.accessoryToControllerNonce = 0;
-        this.accessoryToControllerNonceBuffer = Buffer.alloc(8);
-        this.controllerToAccessoryNonce = 0;
-        this.controllerToAccessoryNonceBuffer = Buffer.alloc(8);
-        this.hapConnectionClosedListener = this.onHAPSessionClosed.bind(this);
-        this.addProtocolHandler("control" /* Protocols.CONTROL */, {
-            requestHandler: {
-                ["hello" /* Topics.HELLO */]: this.handleHello.bind(this),
-            },
+var DataStreamConnection = /** @class */ (function (_super) {
+    tslib_1.__extends(DataStreamConnection, _super);
+    function DataStreamConnection(socket) {
+        var _a;
+        var _this = _super.call(this) || this;
+        /*
+              Since our DataStream server does only listen on one port and this port is supplied to every client
+              which wants to connect, we do not really know which client is who when we receive a tcp connection.
+              Thus, we find the correct PreparedDataStreamSession object by testing the encryption keys of all available
+              prepared sessions. Then we can reference this hds connection with the correct hap connection and mark it as identified.
+           */
+        _this.state = 0 /* ConnectionState.UNIDENTIFIED */;
+        _this.protocolHandlers = {}; // used to store protocolHandlers identified by their protocol name
+        _this.responseHandlers = {}; // used to store responseHandlers indexed by their respective requestId
+        _this.responseTimers = {}; // used to store response timeouts indexed by their respective requestId
+        _this.socket = socket;
+        _this.remoteAddress = socket.remoteAddress;
+        _this.socket.setNoDelay(true); // disable Nagle algorithm
+        _this.socket.setKeepAlive(true);
+        _this.accessoryToControllerNonce = 0;
+        _this.accessoryToControllerNonceBuffer = Buffer.alloc(8);
+        _this.controllerToAccessoryNonce = 0;
+        _this.controllerToAccessoryNonceBuffer = Buffer.alloc(8);
+        _this.hapConnectionClosedListener = _this.onHAPSessionClosed.bind(_this);
+        _this.addProtocolHandler("control" /* Protocols.CONTROL */, {
+            requestHandler: (_a = {},
+                _a["hello" /* Topics.HELLO */] = _this.handleHello.bind(_this),
+                _a),
         });
-        this.helloTimer = setTimeout(() => {
-            debug("[%s] Hello message did not arrive in time. Killing the connection", this.remoteAddress);
-            this.close();
+        _this.helloTimer = setTimeout(function () {
+            debug("[%s] Hello message did not arrive in time. Killing the connection", _this.remoteAddress);
+            _this.close();
         }, 10000);
-        this.socket.on("data", this.onSocketData.bind(this));
-        this.socket.on("error", this.onSocketError.bind(this));
-        this.socket.on("close", this.onSocketClose.bind(this));
+        _this.socket.on("data", _this.onSocketData.bind(_this));
+        _this.socket.on("error", _this.onSocketError.bind(_this));
+        _this.socket.on("close", _this.onSocketClose.bind(_this));
         // this is to mitigate the event emitter "memory leak warning".
         // e.g. with HSV there might be multiple cameras subscribing to the CLOSE event. one subscription for
         // every active recording stream on a camera. The default limit of 10 might be easily reached.
         // Setting a high limit isn't the prefect solution, but will avoid false positives but ensures that
         // a warning is still be printed if running long enough.
-        this.setMaxListeners(100);
+        _this.setMaxListeners(100);
+        return _this;
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handleHello(id, message) {
+    DataStreamConnection.prototype.handleHello = function (id, message) {
         // that hello is indeed the _first_ message received is verified in onSocketData(...)
         debug("[%s] Received hello message from client: %o", this.remoteAddress, message);
         clearTimeout(this.helloTimer);
         this.helloTimer = undefined;
         this.state = 2 /* ConnectionState.READY */;
         this.sendResponse("control" /* Protocols.CONTROL */, "hello" /* Topics.HELLO */, id);
-    }
+    };
     /**
      * Registers a new protocol handler to handle incoming messages.
      * The same protocol cannot be registered multiple times.
@@ -476,25 +485,25 @@ class DataStreamConnection extends events_1.EventEmitter {
      * @param protocol - name of the protocol to register the handler for
      * @param protocolHandler - object to be registered as protocol handler
      */
-    addProtocolHandler(protocol, protocolHandler) {
+    DataStreamConnection.prototype.addProtocolHandler = function (protocol, protocolHandler) {
         if (this.protocolHandlers[protocol] !== undefined) {
             return false;
         }
         this.protocolHandlers[protocol] = protocolHandler;
         return true;
-    }
+    };
     /**
      * Removes a protocol handler if it is registered.
      *
      * @param protocol - name of the protocol to unregister the handler for
      * @param protocolHandler - object which will be unregistered
      */
-    removeProtocolHandler(protocol, protocolHandler) {
-        const current = this.protocolHandlers[protocol];
+    DataStreamConnection.prototype.removeProtocolHandler = function (protocol, protocolHandler) {
+        var current = this.protocolHandlers[protocol];
         if (current === protocolHandler) {
             delete this.protocolHandlers[protocol];
         }
-    }
+    };
     /**
      * Sends a new event message to the connected client.
      *
@@ -503,15 +512,14 @@ class DataStreamConnection extends events_1.EventEmitter {
      * @param message - message dictionary which gets sent along the event
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    sendEvent(protocol, event, message = {}) {
+    DataStreamConnection.prototype.sendEvent = function (protocol, event, message) {
+        if (message === void 0) { message = {}; }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const header = {};
+        var header = {};
         header.protocol = protocol;
         header.event = event;
-        if (this.state === 2 /* ConnectionState.READY */) {
-            this.sendHDSFrame(header, message);
-        }
-    }
+        this.sendHDSFrame(header, message);
+    };
     /**
      * Sends a new request message to the connected client.
      *
@@ -522,29 +530,31 @@ class DataStreamConnection extends events_1.EventEmitter {
      *                   arrive in time or the status and the message dictionary from the response
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    sendRequest(protocol, request, message = {}, callback) {
-        let requestId;
+    DataStreamConnection.prototype.sendRequest = function (protocol, request, message, callback) {
+        var _this = this;
+        if (message === void 0) { message = {}; }
+        var requestId;
         do { // generate unused requestId
             // currently writing int64 to data stream is not really supported, so 32-bit int will be the max
             requestId = Math.floor(Math.random() * 4294967295);
         } while (this.responseHandlers[requestId] !== undefined);
         this.responseHandlers[requestId] = callback;
-        this.responseTimers[requestId] = setTimeout(() => {
+        this.responseTimers[requestId] = setTimeout(function () {
             // we did not receive a response => close socket
-            this.close();
-            const handler = this.responseHandlers[requestId];
-            delete this.responseHandlers[requestId];
-            delete this.responseTimers[requestId];
+            _this.close();
+            var handler = _this.responseHandlers[requestId];
+            delete _this.responseHandlers[requestId];
+            delete _this.responseTimers[requestId];
             // handler should be able to clean up their stuff
             handler(new Error("timeout"), undefined, {});
         }, 10000); // 10s timer
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const header = {};
+        var header = {};
         header.protocol = protocol;
         header.request = request;
         header.id = new DataStreamParser_1.Int64(requestId);
         this.sendHDSFrame(header, message);
-    }
+    };
     /**
      * Send a new response message to a received request message to the client.
      *
@@ -554,40 +564,43 @@ class DataStreamConnection extends events_1.EventEmitter {
      * @param status - status indication if the request was successful. A status of zero indicates success.
      * @param message - message dictionary which gets sent along the response
      */
-    sendResponse(protocol, response, id, status = HDSStatus.SUCCESS, 
+    DataStreamConnection.prototype.sendResponse = function (protocol, response, id, status, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    message = {}) {
+    message) {
+        if (status === void 0) { status = HDSStatus.SUCCESS; }
+        if (message === void 0) { message = {}; }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const header = {};
+        var header = {};
         header.protocol = protocol;
         header.response = response;
         header.id = new DataStreamParser_1.Int64(id);
         header.status = new DataStreamParser_1.Int64(status);
         this.sendHDSFrame(header, message);
-    }
-    onSocketData(data) {
+    };
+    DataStreamConnection.prototype.onSocketData = function (data) {
+        var _this = this;
         if (this.state >= 3 /* ConnectionState.CLOSING */) {
             return;
         }
-        let frameIndex = 0;
-        const frames = this.decodeHDSFrames(data);
+        var frameIndex = 0;
+        var frames = this.decodeHDSFrames(data);
         if (frames.length === 0) { // not enough data
             return;
         }
         if (this.state === 0 /* ConnectionState.UNIDENTIFIED */) {
             // at the beginning we are only interested in trying to decrypt the first frame in order to test decryption keys
-            const firstFrame = frames[frameIndex++];
-            this.emit("identification" /* DataStreamConnectionEvent.IDENTIFICATION */, firstFrame, (identifiedSession) => {
+            var firstFrame = frames[frameIndex++];
+            this.emit("identification" /* DataStreamConnectionEvent.IDENTIFICATION */, firstFrame, function (identifiedSession) {
                 if (identifiedSession) {
                     // horray, we found our connection
-                    this.connection = identifiedSession.connection;
-                    this.accessoryToControllerEncryptionKey = identifiedSession.accessoryToControllerEncryptionKey;
-                    this.controllerToAccessoryEncryptionKey = identifiedSession.controllerToAccessoryEncryptionKey;
-                    this.state = 1 /* ConnectionState.EXPECTING_HELLO */;
+                    _this.connection = identifiedSession.connection;
+                    _this.accessoryToControllerEncryptionKey = identifiedSession.accessoryToControllerEncryptionKey;
+                    _this.controllerToAccessoryEncryptionKey = identifiedSession.controllerToAccessoryEncryptionKey;
+                    _this.state = 1 /* ConnectionState.EXPECTING_HELLO */;
                     // below listener is removed in .close()
-                    this.connection.setMaxListeners(this.connection.getMaxListeners() + 1);
-                    this.connection.on("closed" /* HAPConnectionEvent.CLOSED */, this.hapConnectionClosedListener); // register close listener
-                    debug("[%s] Registering CLOSED handler to HAP connection. Connection currently has %d close handlers!", this.remoteAddress, this.connection.listeners("closed" /* HAPConnectionEvent.CLOSED */).length);
+                    _this.connection.setMaxListeners(_this.connection.getMaxListeners() + 1);
+                    _this.connection.on("closed" /* HAPConnectionEvent.CLOSED */, _this.hapConnectionClosedListener); // register close listener
+                    debug("[%s] Registering CLOSED handler to HAP connection. Connection currently has %d close handlers!", _this.remoteAddress, _this.connection.listeners("closed" /* HAPConnectionEvent.CLOSED */).length);
                 }
             });
             if (this.state === 0 /* ConnectionState.UNIDENTIFIED */) {
@@ -602,9 +615,9 @@ class DataStreamConnection extends events_1.EventEmitter {
                 return;
             }
         }
-        const messages = this.decodePayloads(frames); // decode contents of payload
+        var messages = this.decodePayloads(frames); // decode contents of payload
         if (this.state === 1 /* ConnectionState.EXPECTING_HELLO */) {
-            const firstMessage = messages[0];
+            var firstMessage = messages[0];
             if (firstMessage.protocol !== "control" /* Protocols.CONTROL */ || firstMessage.type !== 2 /* MessageType.REQUEST */ || firstMessage.topic !== "hello" /* Topics.HELLO */) {
                 // first message is not the expected hello request
                 debug("[%s] First message received was not the expected hello message. Instead got: %o", this.remoteAddress, firstMessage);
@@ -612,15 +625,15 @@ class DataStreamConnection extends events_1.EventEmitter {
                 return;
             }
         }
-        messages.forEach(message => {
+        messages.forEach(function (message) {
             if (message.type === 3 /* MessageType.RESPONSE */) {
                 // protocol and topic are currently not tested here; just assumed they are correct;
                 // probably they are as the requestId is unique per connection no matter what protocol is used
-                const responseHandler = this.responseHandlers[message.id];
-                const responseTimer = this.responseTimers[message.id];
+                var responseHandler = _this.responseHandlers[message.id];
+                var responseTimer = _this.responseTimers[message.id];
                 if (responseTimer) {
                     clearTimeout(responseTimer);
-                    delete this.responseTimers[message.id];
+                    delete _this.responseTimers[message.id];
                 }
                 if (!responseHandler) {
                     // we got a response to a request we did not send; we ignore it for now, since nobody will be hurt
@@ -631,88 +644,88 @@ class DataStreamConnection extends events_1.EventEmitter {
                     responseHandler(undefined, message.status, message.message);
                 }
                 catch (error) {
-                    debug("[%s] Error occurred while dispatching response handler for HDS message: %o", this.remoteAddress, message);
+                    debug("[%s] Error occurred while dispatching response handler for HDS message: %o", _this.remoteAddress, message);
                     debug(error.stack);
                 }
-                delete this.responseHandlers[message.id];
+                delete _this.responseHandlers[message.id];
             }
             else {
-                const handler = this.protocolHandlers[message.protocol];
+                var handler = _this.protocolHandlers[message.protocol];
                 if (handler === undefined) {
                     // send message to the server to check if there are some global handlers for it
-                    this.emit("handle-message-globally" /* DataStreamConnectionEvent.HANDLE_MESSAGE_GLOBALLY */, message);
+                    _this.emit("handle-message-globally" /* DataStreamConnectionEvent.HANDLE_MESSAGE_GLOBALLY */, message);
                     return;
                 }
                 if (message.type === 1 /* MessageType.EVENT */) {
-                    let eventHandler;
+                    var eventHandler = void 0;
                     if (!handler.eventHandler || !(eventHandler = handler.eventHandler[message.topic])) {
-                        debug("[%s] WARNING no event handler was found for message: %o", this.remoteAddress, message);
+                        debug("[%s] WARNING no event handler was found for message: %o", _this.remoteAddress, message);
                         return;
                     }
                     try {
                         eventHandler(message.message);
                     }
                     catch (error) {
-                        debug("[%s] Error occurred while dispatching event handler for HDS message: %o", this.remoteAddress, message);
+                        debug("[%s] Error occurred while dispatching event handler for HDS message: %o", _this.remoteAddress, message);
                         debug(error.stack);
                     }
                 }
                 else if (message.type === 2 /* MessageType.REQUEST */) {
-                    let requestHandler;
+                    var requestHandler = void 0;
                     if (!handler.requestHandler || !(requestHandler = handler.requestHandler[message.topic])) {
-                        debug("[%s] WARNING no request handler was found for message: %o", this.remoteAddress, message);
+                        debug("[%s] WARNING no request handler was found for message: %o", _this.remoteAddress, message);
                         return;
                     }
                     try {
                         requestHandler(message.id, message.message);
                     }
                     catch (error) {
-                        debug("[%s] Error occurred while dispatching request handler for HDS message: %o", this.remoteAddress, message);
+                        debug("[%s] Error occurred while dispatching request handler for HDS message: %o", _this.remoteAddress, message);
                         debug(error.stack);
                     }
                 }
                 else {
-                    debug("[%s] Encountered unknown message type with id %d", this.remoteAddress, message.type);
+                    debug("[%s] Encountered unknown message type with id %d", _this.remoteAddress, message.type);
                 }
             }
         });
-    }
-    decodeHDSFrames(data) {
+    };
+    DataStreamConnection.prototype.decodeHDSFrames = function (data) {
         if (this.frameBuffer !== undefined) {
             data = Buffer.concat([this.frameBuffer, data]);
             this.frameBuffer = undefined;
         }
-        const totalBufferLength = data.length;
-        const frames = [];
-        for (let frameBegin = 0; frameBegin < totalBufferLength;) {
+        var totalBufferLength = data.length;
+        var frames = [];
+        for (var frameBegin = 0; frameBegin < totalBufferLength;) {
             if (frameBegin + 4 > totalBufferLength) {
                 // we don't have enough data in the buffer for the next header
                 this.frameBuffer = data.slice(frameBegin);
                 break;
             }
-            const payloadType = data.readUInt8(frameBegin); // type defining structure of payload; 8-bit; currently expected to be 1
-            const payloadLength = data.readUIntBE(frameBegin + 1, 3); // read 24-bit big-endian uint length field
+            var payloadType = data.readUInt8(frameBegin); // type defining structure of payload; 8-bit; currently expected to be 1
+            var payloadLength = data.readUIntBE(frameBegin + 1, 3); // read 24-bit big-endian uint length field
             if (payloadLength > DataStreamConnection.MAX_PAYLOAD_LENGTH) {
                 debug("[%s] Connection send payload with size bigger than the maximum allow for data stream", this.remoteAddress);
                 this.close();
                 return [];
             }
-            const remainingBufferLength = totalBufferLength - frameBegin - 4; // subtract 4 for payloadType (1-byte) and payloadLength (3-byte)
+            var remainingBufferLength = totalBufferLength - frameBegin - 4; // subtract 4 for payloadType (1-byte) and payloadLength (3-byte)
             // check if the data from this frame is already there (payload + 16-byte authTag)
             if (payloadLength + 16 > remainingBufferLength) {
                 // Frame is fragmented, so we wait until we receive more
                 this.frameBuffer = data.slice(frameBegin);
                 break;
             }
-            const payloadBegin = frameBegin + 4;
-            const authTagBegin = payloadBegin + payloadLength;
-            const header = data.slice(frameBegin, payloadBegin); // header is also authenticated using authTag
-            const cipheredPayload = data.slice(payloadBegin, authTagBegin);
-            const plaintextPayload = Buffer.alloc(payloadLength);
-            const authTag = data.slice(authTagBegin, authTagBegin + 16);
+            var payloadBegin = frameBegin + 4;
+            var authTagBegin = payloadBegin + payloadLength;
+            var header = data.slice(frameBegin, payloadBegin); // header is also authenticated using authTag
+            var cipheredPayload = data.slice(payloadBegin, authTagBegin);
+            var plaintextPayload = Buffer.alloc(payloadLength);
+            var authTag = data.slice(authTagBegin, authTagBegin + 16);
             frameBegin = authTagBegin + 16; // move to next frame
             if (payloadType === 1) {
-                const hdsFrame = {
+                var hdsFrame = {
                     header: header,
                     cipheredPayload: cipheredPayload,
                     authTag: authTag,
@@ -724,13 +737,13 @@ class DataStreamConnection extends events_1.EventEmitter {
             }
         }
         return frames;
-    }
+    };
     /**
      * @private file-private API
      */
-    decryptHDSFrame(frame, keyOverwrite) {
+    DataStreamConnection.prototype.decryptHDSFrame = function (frame, keyOverwrite) {
         hapCrypto.writeUInt64LE(this.controllerToAccessoryNonce, this.controllerToAccessoryNonceBuffer, 0); // update nonce buffer
-        const key = keyOverwrite || this.controllerToAccessoryEncryptionKey;
+        var key = keyOverwrite || this.controllerToAccessoryEncryptionKey;
         try {
             frame.plaintextPayload = hapCrypto.chacha20_poly1305_decryptAndVerify(key, this.controllerToAccessoryNonceBuffer, frame.header, frame.cipheredPayload, frame.authTag);
             this.controllerToAccessoryNonce++; // we had a successful encryption, increment the nonce
@@ -740,30 +753,31 @@ class DataStreamConnection extends events_1.EventEmitter {
             // frame decryption or authentication failed. Could happen when our guess for a PreparedDataStreamSession is wrong
             return false;
         }
-    }
-    decodePayloads(frames) {
-        const messages = [];
-        frames.forEach(frame => {
-            const payload = frame.plaintextPayload;
+    };
+    DataStreamConnection.prototype.decodePayloads = function (frames) {
+        var _this = this;
+        var messages = [];
+        frames.forEach(function (frame) {
+            var payload = frame.plaintextPayload;
             if (!payload) {
                 throw new HDSConnectionError("Reached illegal state. Encountered HDSFrame with wasn't decrypted yet!", 1 /* HDSConnectionErrorType.ILLEGAL_STATE */);
             }
-            const headerLength = payload.readUInt8(0);
-            const messageLength = payload.length - headerLength - 1;
-            const headerBegin = 1;
-            const messageBegin = headerBegin + headerLength;
-            const headerPayload = new DataStreamParser_1.DataStreamReader(payload.slice(headerBegin, headerBegin + headerLength));
-            const messagePayload = new DataStreamParser_1.DataStreamReader(payload.slice(messageBegin, messageBegin + messageLength));
+            var headerLength = payload.readUInt8(0);
+            var messageLength = payload.length - headerLength - 1;
+            var headerBegin = 1;
+            var messageBegin = headerBegin + headerLength;
+            var headerPayload = new DataStreamParser_1.DataStreamReader(payload.slice(headerBegin, headerBegin + headerLength));
+            var messagePayload = new DataStreamParser_1.DataStreamReader(payload.slice(messageBegin, messageBegin + messageLength));
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let headerDictionary;
+            var headerDictionary;
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let messageDictionary;
+            var messageDictionary;
             try {
                 headerDictionary = DataStreamParser_1.DataStreamParser.decode(headerPayload);
                 headerPayload.finished();
             }
             catch (error) {
-                debug("[%s] Failed to decode header payload: %s", this.remoteAddress, error.message);
+                debug("[%s] Failed to decode header payload: %s", _this.remoteAddress, error.message);
                 return;
             }
             try {
@@ -771,14 +785,14 @@ class DataStreamConnection extends events_1.EventEmitter {
                 messagePayload.finished();
             }
             catch (error) {
-                debug("[%s] Failed to decode message payload: %s (header: %o)", this.remoteAddress, error.message, headerDictionary);
+                debug("[%s] Failed to decode message payload: %s (header: %o)", _this.remoteAddress, error.message, headerDictionary);
                 return;
             }
-            let type;
-            const protocol = headerDictionary.protocol;
-            let topic;
-            let id = undefined;
-            let status = undefined;
+            var type;
+            var protocol = headerDictionary.protocol;
+            var topic;
+            var id = undefined;
+            var status = undefined;
             if (headerDictionary.event !== undefined) {
                 type = 1 /* MessageType.EVENT */;
                 topic = headerDictionary.event;
@@ -795,10 +809,10 @@ class DataStreamConnection extends events_1.EventEmitter {
                 status = headerDictionary.status;
             }
             else {
-                debug("[%s] Encountered unknown payload header format: %o (message: %o)", this.remoteAddress, headerDictionary, messageDictionary);
+                debug("[%s] Encountered unknown payload header format: %o (message: %o)", _this.remoteAddress, headerDictionary, messageDictionary);
                 return;
             }
-            const message = {
+            var message = {
                 type: type,
                 protocol: protocol,
                 topic: topic,
@@ -809,30 +823,30 @@ class DataStreamConnection extends events_1.EventEmitter {
             messages.push(message);
         });
         return messages;
-    }
+    };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    sendHDSFrame(header, message) {
+    DataStreamConnection.prototype.sendHDSFrame = function (header, message) {
         if (this.state >= 3 /* ConnectionState.CLOSING */) {
             throw new HDSConnectionError("Cannot send message on closing/closed socket!", 2 /* HDSConnectionErrorType.CLOSED_SOCKET */);
         }
-        const headerWriter = new DataStreamParser_1.DataStreamWriter();
-        const messageWriter = new DataStreamParser_1.DataStreamWriter();
+        var headerWriter = new DataStreamParser_1.DataStreamWriter();
+        var messageWriter = new DataStreamParser_1.DataStreamWriter();
         DataStreamParser_1.DataStreamParser.encode(header, headerWriter);
         DataStreamParser_1.DataStreamParser.encode(message, messageWriter);
-        const payloadHeaderBuffer = Buffer.alloc(1);
+        var payloadHeaderBuffer = Buffer.alloc(1);
         payloadHeaderBuffer.writeUInt8(headerWriter.length(), 0);
-        const payloadBuffer = Buffer.concat([payloadHeaderBuffer, headerWriter.getData(), messageWriter.getData()]);
+        var payloadBuffer = Buffer.concat([payloadHeaderBuffer, headerWriter.getData(), messageWriter.getData()]);
         if (payloadBuffer.length > DataStreamConnection.MAX_PAYLOAD_LENGTH) {
             throw new HDSConnectionError("Tried sending payload with length larger than the maximum allowed for data stream", 3 /* HDSConnectionErrorType.MAX_PAYLOAD_LENGTH */);
         }
-        const frameTypeBuffer = Buffer.alloc(1);
+        var frameTypeBuffer = Buffer.alloc(1);
         frameTypeBuffer.writeUInt8(1, 0);
-        let frameLengthBuffer = Buffer.alloc(4);
+        var frameLengthBuffer = Buffer.alloc(4);
         frameLengthBuffer.writeUInt32BE(payloadBuffer.length, 0);
         frameLengthBuffer = frameLengthBuffer.slice(1, 4); // a bit hacky but the only real way to write 24-bit int in node
-        const frameHeader = Buffer.concat([frameTypeBuffer, frameLengthBuffer]);
+        var frameHeader = Buffer.concat([frameTypeBuffer, frameLengthBuffer]);
         hapCrypto.writeUInt64LE(this.accessoryToControllerNonce++, this.accessoryToControllerNonceBuffer);
-        const encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(this.accessoryToControllerEncryptionKey, this.accessoryToControllerNonceBuffer, frameHeader, payloadBuffer);
+        var encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(this.accessoryToControllerEncryptionKey, this.accessoryToControllerNonceBuffer, frameHeader, payloadBuffer);
         this.socket.write(Buffer.concat([frameHeader, encrypted.ciphertext, encrypted.authTag]));
         /* Useful for debugging outgoing packages and detecting encoding errors
             console.log("SENT DATA: " + payloadBuffer.toString("hex"));
@@ -845,34 +859,37 @@ class DataStreamConnection extends events_1.EventEmitter {
             const sentMessage = this.decodePayloads([frame])[0];
             console.log("Sent message: " + JSON.stringify(sentMessage, null, 4));
             //*/
-    }
-    close() {
+    };
+    DataStreamConnection.prototype.close = function () {
         if (this.state >= 3 /* ConnectionState.CLOSING */) {
             return; // connection is already closing/closed
         }
         this.state = 3 /* ConnectionState.CLOSING */;
         this.socket.end();
-    }
-    isConsideredClosed() {
+    };
+    DataStreamConnection.prototype.isConsideredClosed = function () {
         return this.state >= 3 /* ConnectionState.CLOSING */;
-    }
-    onHAPSessionClosed() {
+    };
+    DataStreamConnection.prototype.onHAPSessionClosed = function () {
         // If the hap connection is closed it is probably also a good idea to close the data stream connection
         debug("[%s] HAP connection disconnected. Also closing DataStream connection now.", this.remoteAddress);
         this.close();
-    }
-    onSocketError(error) {
+    };
+    DataStreamConnection.prototype.onSocketError = function (error) {
         debug("[%s] Encountered socket error: %s", this.remoteAddress, error.message);
         // onSocketClose will be called next
-    }
-    onSocketClose() {
+    };
+    DataStreamConnection.prototype.onSocketClose = function () {
+        var _a, _b;
         // this instance is now considered completely dead
         this.state = 4 /* ConnectionState.CLOSED */;
         this.emit("closed" /* DataStreamConnectionEvent.CLOSED */);
-        this.connection?.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.hapConnectionClosedListener);
-        this.connection?.setMaxListeners(this.connection.getMaxListeners() - 1);
+        (_a = this.connection) === null || _a === void 0 ? void 0 : _a.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.hapConnectionClosedListener);
+        (_b = this.connection) === null || _b === void 0 ? void 0 : _b.setMaxListeners(this.connection.getMaxListeners() - 1);
         this.removeAllListeners();
-    }
-}
+    };
+    DataStreamConnection.MAX_PAYLOAD_LENGTH = 1048575;
+    return DataStreamConnection;
+}(events_1.EventEmitter));
 exports.DataStreamConnection = DataStreamConnection;
 //# sourceMappingURL=DataStreamServer.js.map