hap-nodejs 0.12.3-beta.2 → 0.12.3-beta.21

package/dist/lib/HAPServer.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HAPServer = exports.HAPServerEventTypes = exports.HAPPairingHTTPCode = exports.HAPHTTPCode = exports.Status = exports.Codes = exports.HAPStatus = exports.TLVErrorCode = void 0;
+exports.HAPServer = exports.HAPServerEventTypes = exports.HAPPairingHTTPCode = exports.HAPHTTPCode = exports.HAPStatus = exports.TLVErrorCode = void 0;
 exports.IsKnownHAPStatusError = IsKnownHAPStatusError;
-var tslib_1 = require("tslib");
-var crypto_1 = tslib_1.__importDefault(require("crypto"));
-var debug_1 = tslib_1.__importDefault(require("debug"));
-var events_1 = require("events");
-var fast_srp_hap_1 = require("fast-srp-hap");
-var tweetnacl_1 = tslib_1.__importDefault(require("tweetnacl"));
-var url_1 = require("url");
-var internal_types_1 = require("../internal-types");
-var eventedhttp_1 = require("./util/eventedhttp");
-var hapCrypto = tslib_1.__importStar(require("./util/hapCrypto"));
-var once_1 = require("./util/once");
-var tlv = tslib_1.__importStar(require("./util/tlv"));
-var debug = (0, debug_1.default)("HAP-NodeJS:HAPServer");
+const tslib_1 = require("tslib");
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const events_1 = require("events");
+const fast_srp_hap_1 = require("fast-srp-hap");
+const tweetnacl_1 = tslib_1.__importDefault(require("tweetnacl"));
+const url_1 = require("url");
+const internal_types_1 = require("../internal-types");
+const eventedhttp_1 = require("./util/eventedhttp");
+const hapCrypto = tslib_1.__importStar(require("./util/hapCrypto"));
+const once_1 = require("./util/once");
+const tlv = tslib_1.__importStar(require("./util/tlv"));
+const debug = (0, debug_1.default)("HAP-NodeJS:HAPServer");
 /**
  * TLV error codes for the `TLVValues.ERROR_CODE` field.
  *
@@ -105,20 +105,6 @@ function IsKnownHAPStatusError(status) {
         // Upper bound (negative error code closest to zero)
         status <= -70401 /* HAPStatus.INSUFFICIENT_PRIVILEGES */);
 }
-// noinspection JSUnusedGlobalSymbols
-/**
- * @group HAP Accessory Server
- * @deprecated please use {@link TLVErrorCode} as naming is more precise
- */
-// @ts-expect-error (as we use const enums with --preserveConstEnums)
-exports.Codes = TLVErrorCode;
-// noinspection JSUnusedGlobalSymbols
-/**
- * @group HAP Accessory Server
- * @deprecated please use {@link HAPStatus} as naming is more precise
- */
-// @ts-expect-error (as we use const enums with --preserveConstEnums)
-exports.Status = HAPStatus;
 /**
  * Those status codes are the one listed as appropriate for the HAP spec!
  *
@@ -228,36 +214,36 @@ var HAPServerEventTypes;
  * @group HAP Accessory Server
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-var HAPServer = /** @class */ (function (_super) {
-    tslib_1.__extends(HAPServer, _super);
-    function HAPServer(accessoryInfo) {
-        var _this = _super.call(this) || this;
-        _this.unsuccessfulPairAttempts = 0; // after 100 unsuccessful attempts the server won't accept any further attempts. Will currently be reset on a reboot
-        _this.accessoryInfo = accessoryInfo;
-        _this.allowInsecureRequest = false;
+class HAPServer extends events_1.EventEmitter {
+    accessoryInfo;
+    httpServer;
+    unsuccessfulPairAttempts = 0; // after 100 unsuccessful attempts the server won't accept any further attempts. Will currently be reset on a reboot
+    allowInsecureRequest;
+    constructor(accessoryInfo) {
+        super();
+        this.accessoryInfo = accessoryInfo;
+        this.allowInsecureRequest = false;
         // internal server that does all the actual communication
-        _this.httpServer = new eventedhttp_1.EventedHTTPServer();
-        _this.httpServer.on("listening" /* EventedHTTPServerEvent.LISTENING */, _this.onListening.bind(_this));
-        _this.httpServer.on("request" /* EventedHTTPServerEvent.REQUEST */, _this.handleRequestOnHAPConnection.bind(_this));
-        _this.httpServer.on("connection-closed" /* EventedHTTPServerEvent.CONNECTION_CLOSED */, _this.handleConnectionClosed.bind(_this));
-        return _this;
+        this.httpServer = new eventedhttp_1.EventedHTTPServer();
+        this.httpServer.on("listening" /* EventedHTTPServerEvent.LISTENING */, this.onListening.bind(this));
+        this.httpServer.on("request" /* EventedHTTPServerEvent.REQUEST */, this.handleRequestOnHAPConnection.bind(this));
+        this.httpServer.on("connection-closed" /* EventedHTTPServerEvent.CONNECTION_CLOSED */, this.handleConnectionClosed.bind(this));
     }
-    HAPServer.prototype.listen = function (port, host) {
-        if (port === void 0) { port = 0; }
+    listen(port = 0, host) {
         if (host === "::") {
             // this will work around "EAFNOSUPPORT: address family not supported" errors
             // on systems where IPv6 is not supported/enabled, we just use the node default then by supplying undefined
             host = undefined;
         }
         this.httpServer.listen(port, host);
-    };
-    HAPServer.prototype.stop = function () {
+    }
+    stop() {
         this.httpServer.stop();
-    };
-    HAPServer.prototype.destroy = function () {
+    }
+    destroy() {
         this.stop();
         this.removeAllListeners();
-    };
+    }
     /**
      * Send an even notification for given characteristic and changed value to all connected clients.
      * If `originator` is specified, the given {@link HAPConnection} will be excluded from the broadcast.
@@ -269,48 +255,47 @@ var HAPServer = /** @class */ (function (_super) {
      * @param immediateDelivery - The HAP spec requires some characteristics to be delivery immediately.
      *   Namely, for the {@link Characteristic.ButtonEvent} and the {@link Characteristic.ProgrammableSwitchEvent} characteristics.
      */
-    HAPServer.prototype.sendEventNotifications = function (aid, iid, value, originator, immediateDelivery) {
+    sendEventNotifications(aid, iid, value, originator, immediateDelivery) {
         try {
             this.httpServer.broadcastEvent(aid, iid, value, originator, immediateDelivery);
         }
         catch (error) {
             console.warn("[" + this.accessoryInfo.username + "] Error when sending event notifications: " + error.message);
         }
-    };
-    HAPServer.prototype.onListening = function (port, hostname) {
+    }
+    onListening(port, hostname) {
         this.emit("listening" /* HAPServerEventTypes.LISTENING */, port, hostname);
-    };
+    }
     // Called when an HTTP request was detected.
-    HAPServer.prototype.handleRequestOnHAPConnection = function (connection, request, response) {
-        var _this = this;
+    handleRequestOnHAPConnection(connection, request, response) {
         debug("[%s] HAP Request: %s %s", this.accessoryInfo.username, request.method, request.url);
-        var buffers = [];
-        request.on("data", function (data) { return buffers.push(data); });
-        request.on("end", function () {
-            var url = new url_1.URL(request.url, "http://hap-nodejs.local"); // parse the url (query strings etc)
-            var handler = _this.getHandler(url);
+        const buffers = [];
+        request.on("data", data => buffers.push(data));
+        request.on("end", () => {
+            const url = new url_1.URL(request.url, "http://hap-nodejs.local"); // parse the url (query strings etc)
+            const handler = this.getHandler(url);
             if (!handler) {
-                debug("[%s] WARNING: Handler for %s not implemented", _this.accessoryInfo.username, request.url);
+                debug("[%s] WARNING: Handler for %s not implemented", this.accessoryInfo.username, request.url);
                 response.writeHead(404 /* HAPHTTPCode.NOT_FOUND */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                 response.end(JSON.stringify({ status: -70409 /* HAPStatus.RESOURCE_DOES_NOT_EXIST */ }));
             }
             else {
-                var data = Buffer.concat(buffers);
+                const data = Buffer.concat(buffers);
                 try {
                     handler(connection, url, request, data, response);
                 }
                 catch (error) {
-                    debug("[%s] Error executing route handler: %s", _this.accessoryInfo.username, error.stack);
+                    debug("[%s] Error executing route handler: %s", this.accessoryInfo.username, error.stack);
                     response.writeHead(500 /* HAPHTTPCode.INTERNAL_SERVER_ERROR */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                     response.end(JSON.stringify({ status: -70403 /* HAPStatus.RESOURCE_BUSY */ })); // resource busy try again, does somehow fit?
                 }
             }
         });
-    };
-    HAPServer.prototype.handleConnectionClosed = function (connection) {
+    }
+    handleConnectionClosed(connection) {
         this.emit("connection-closed" /* HAPServerEventTypes.CONNECTION_CLOSED */, connection);
-    };
-    HAPServer.prototype.getHandler = function (url) {
+    }
+    getHandler(url) {
         switch (url.pathname.toLowerCase()) {
             case "/identify":
                 return this.handleIdentifyRequest.bind(this);
@@ -331,32 +316,31 @@ var HAPServer = /** @class */ (function (_super) {
             default:
                 return undefined;
         }
-    };
+    }
     /**
      * UNPAIRED Accessory identification.
      */
-    HAPServer.prototype.handleIdentifyRequest = function (connection, url, request, data, response) {
-        var _this = this;
+    handleIdentifyRequest(connection, url, request, data, response) {
         // POST body is empty
         if (this.accessoryInfo.paired() && !this.allowInsecureRequest) {
             response.writeHead(400 /* HAPHTTPCode.BAD_REQUEST */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
             response.end(JSON.stringify({ status: -70401 /* HAPStatus.INSUFFICIENT_PRIVILEGES */ }));
             return;
         }
-        this.emit("identify" /* HAPServerEventTypes.IDENTIFY */, (0, once_1.once)(function (err) {
+        this.emit("identify" /* HAPServerEventTypes.IDENTIFY */, (0, once_1.once)(err => {
             if (!err) {
-                debug("[%s] Identification success", _this.accessoryInfo.username);
+                debug("[%s] Identification success", this.accessoryInfo.username);
                 response.writeHead(204 /* HAPHTTPCode.NO_CONTENT */);
                 response.end();
             }
             else {
-                debug("[%s] Identification error: %s", _this.accessoryInfo.username, err.message);
+                debug("[%s] Identification error: %s", this.accessoryInfo.username, err.message);
                 response.writeHead(500 /* HAPHTTPCode.INTERNAL_SERVER_ERROR */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                 response.end(JSON.stringify({ status: -70403 /* HAPStatus.RESOURCE_BUSY */ }));
             }
         }));
-    };
-    HAPServer.prototype.handlePairSetup = function (connection, url, request, data, response) {
+    }
+    handlePairSetup(connection, url, request, data, response) {
         // Can only be directly paired with one iOS device
         if (!this.allowInsecureRequest && this.accessoryInfo.paired()) {
             response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
@@ -369,8 +353,8 @@ var HAPServer = /** @class */ (function (_super) {
             response.end(tlv.encode(6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */, 7 /* TLVValues.ERROR_CODE */, 5 /* TLVErrorCode.MAX_TRIES */));
             return;
         }
-        var tlvData = tlv.decode(data);
-        var sequence = tlvData[6 /* TLVValues.SEQUENCE_NUM */][0]; // value is single byte with sequence number
+        const tlvData = tlv.decode(data);
+        const sequence = tlvData[6 /* TLVValues.SEQUENCE_NUM */][0]; // value is single byte with sequence number
         if (sequence === 1 /* PairingStates.M1 */) {
             this.handlePairSetupM1(connection, request, response);
         }
@@ -386,34 +370,33 @@ var HAPServer = /** @class */ (function (_super) {
             response.end(tlv.encode(6 /* TLVValues.STATE */, sequence + 1, 7 /* TLVValues.ERROR_CODE */, 1 /* TLVErrorCode.UNKNOWN */));
             return;
         }
-    };
-    HAPServer.prototype.handlePairSetupM1 = function (connection, request, response) {
-        var _this = this;
+    }
+    handlePairSetupM1(connection, request, response) {
         debug("[%s] Pair step 1/5", this.accessoryInfo.username);
-        var salt = crypto_1.default.randomBytes(16);
-        var srpParams = fast_srp_hap_1.SRP.params.hap;
-        fast_srp_hap_1.SRP.genKey(32).then(function (key) {
+        const salt = crypto_1.default.randomBytes(16);
+        const srpParams = fast_srp_hap_1.SRP.params.hap;
+        fast_srp_hap_1.SRP.genKey(32).then(key => {
             // create a new SRP server
-            var srpServer = new fast_srp_hap_1.SrpServer(srpParams, salt, Buffer.from("Pair-Setup"), Buffer.from(_this.accessoryInfo.pincode), key);
-            var srpB = srpServer.computeB();
+            const srpServer = new fast_srp_hap_1.SrpServer(srpParams, salt, Buffer.from("Pair-Setup"), Buffer.from(this.accessoryInfo.pincode), key);
+            const srpB = srpServer.computeB();
             // attach it to the current TCP session
             connection.srpServer = srpServer;
             response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
             response.end(tlv.encode(6 /* TLVValues.SEQUENCE_NUM */, 2 /* PairingStates.M2 */, 2 /* TLVValues.SALT */, salt, 3 /* TLVValues.PUBLIC_KEY */, srpB));
             connection._pairSetupState = 2 /* PairingStates.M2 */;
-        }).catch(function (error) {
-            debug("[%s] Error occurred when generating srp key: %s", _this.accessoryInfo.username, error.message);
+        }).catch(error => {
+            debug("[%s] Error occurred when generating srp key: %s", this.accessoryInfo.username, error.message);
             response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
             response.end(tlv.encode(6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */, 7 /* TLVValues.ERROR_CODE */, 1 /* TLVErrorCode.UNKNOWN */));
             return;
         });
-    };
-    HAPServer.prototype.handlePairSetupM3 = function (connection, request, response, tlvData) {
+    }
+    handlePairSetupM3(connection, request, response, tlvData) {
         debug("[%s] Pair step 2/5", this.accessoryInfo.username);
-        var A = tlvData[3 /* TLVValues.PUBLIC_KEY */]; // "A is a public key that exists only for a single login session."
-        var M1 = tlvData[4 /* TLVValues.PASSWORD_PROOF */]; // "M1 is the proof that you actually know your own password."
+        const A = tlvData[3 /* TLVValues.PUBLIC_KEY */]; // "A is a public key that exists only for a single login session."
+        const M1 = tlvData[4 /* TLVValues.PASSWORD_PROOF */]; // "M1 is the proof that you actually know your own password."
         // pull the SRP server we created in stepOne out of the current session
-        var srpServer = connection.srpServer;
+        const srpServer = connection.srpServer;
         srpServer.setA(A);
         try {
             srpServer.checkM1(M1);
@@ -428,25 +411,25 @@ var HAPServer = /** @class */ (function (_super) {
             return;
         }
         // "M2 is the proof that the server actually knows your password."
-        var M2 = srpServer.computeM2();
+        const M2 = srpServer.computeM2();
         response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
         response.end(tlv.encode(6 /* TLVValues.SEQUENCE_NUM */, 4 /* PairingStates.M4 */, 4 /* TLVValues.PASSWORD_PROOF */, M2));
         connection._pairSetupState = 4 /* PairingStates.M4 */;
-    };
-    HAPServer.prototype.handlePairSetupM5 = function (connection, request, response, tlvData) {
+    }
+    handlePairSetupM5(connection, request, response, tlvData) {
         debug("[%s] Pair step 3/5", this.accessoryInfo.username);
         // pull the SRP server we created in stepOne out of the current session
-        var srpServer = connection.srpServer;
-        var encryptedData = tlvData[5 /* TLVValues.ENCRYPTED_DATA */];
-        var messageData = Buffer.alloc(encryptedData.length - 16);
-        var authTagData = Buffer.alloc(16);
+        const srpServer = connection.srpServer;
+        const encryptedData = tlvData[5 /* TLVValues.ENCRYPTED_DATA */];
+        const messageData = Buffer.alloc(encryptedData.length - 16);
+        const authTagData = Buffer.alloc(16);
         encryptedData.copy(messageData, 0, 0, encryptedData.length - 16);
         encryptedData.copy(authTagData, 0, encryptedData.length - 16, encryptedData.length);
-        var S_private = srpServer.computeK();
-        var encSalt = Buffer.from("Pair-Setup-Encrypt-Salt");
-        var encInfo = Buffer.from("Pair-Setup-Encrypt-Info");
-        var outputKey = hapCrypto.HKDF("sha512", encSalt, S_private, encInfo, 32);
-        var plaintext;
+        const S_private = srpServer.computeK();
+        const encSalt = Buffer.from("Pair-Setup-Encrypt-Salt");
+        const encInfo = Buffer.from("Pair-Setup-Encrypt-Info");
+        const outputKey = hapCrypto.HKDF("sha512", encSalt, S_private, encInfo, 32);
+        let plaintext;
         try {
             plaintext = hapCrypto.chacha20_poly1305_decryptAndVerify(outputKey, Buffer.from("PS-Msg05"), null, messageData, authTagData);
         }
@@ -458,20 +441,20 @@ var HAPServer = /** @class */ (function (_super) {
             return;
         }
         // decode the client payload and pass it on to the next step
-        var M5Packet = tlv.decode(plaintext);
-        var clientUsername = M5Packet[1 /* TLVValues.USERNAME */];
-        var clientLTPK = M5Packet[3 /* TLVValues.PUBLIC_KEY */];
-        var clientProof = M5Packet[10 /* TLVValues.PROOF */];
+        const M5Packet = tlv.decode(plaintext);
+        const clientUsername = M5Packet[1 /* TLVValues.USERNAME */];
+        const clientLTPK = M5Packet[3 /* TLVValues.PUBLIC_KEY */];
+        const clientProof = M5Packet[10 /* TLVValues.PROOF */];
         this.handlePairSetupM5_2(connection, request, response, clientUsername, clientLTPK, clientProof, outputKey);
-    };
+    }
     // M5-2
-    HAPServer.prototype.handlePairSetupM5_2 = function (connection, request, response, clientUsername, clientLTPK, clientProof, hkdfEncKey) {
+    handlePairSetupM5_2(connection, request, response, clientUsername, clientLTPK, clientProof, hkdfEncKey) {
         debug("[%s] Pair step 4/5", this.accessoryInfo.username);
-        var S_private = connection.srpServer.computeK();
-        var controllerSalt = Buffer.from("Pair-Setup-Controller-Sign-Salt");
-        var controllerInfo = Buffer.from("Pair-Setup-Controller-Sign-Info");
-        var outputKey = hapCrypto.HKDF("sha512", controllerSalt, S_private, controllerInfo, 32);
-        var completeData = Buffer.concat([outputKey, clientUsername, clientLTPK]);
+        const S_private = connection.srpServer.computeK();
+        const controllerSalt = Buffer.from("Pair-Setup-Controller-Sign-Salt");
+        const controllerInfo = Buffer.from("Pair-Setup-Controller-Sign-Info");
+        const outputKey = hapCrypto.HKDF("sha512", controllerSalt, S_private, controllerInfo, 32);
+        const completeData = Buffer.concat([outputKey, clientUsername, clientLTPK]);
         if (!tweetnacl_1.default.sign.detached.verify(completeData, clientProof, clientLTPK)) {
             debug("[%s] Invalid signature", this.accessoryInfo.username);
             response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
@@ -480,26 +463,25 @@ var HAPServer = /** @class */ (function (_super) {
             return;
         }
         this.handlePairSetupM5_3(connection, request, response, clientUsername, clientLTPK, hkdfEncKey);
-    };
+    }
     // M5 - F + M6
-    HAPServer.prototype.handlePairSetupM5_3 = function (connection, request, response, clientUsername, clientLTPK, hkdfEncKey) {
-        var _this = this;
+    handlePairSetupM5_3(connection, request, response, clientUsername, clientLTPK, hkdfEncKey) {
         debug("[%s] Pair step 5/5", this.accessoryInfo.username);
-        var S_private = connection.srpServer.computeK();
-        var accessorySalt = Buffer.from("Pair-Setup-Accessory-Sign-Salt");
-        var accessoryInfo = Buffer.from("Pair-Setup-Accessory-Sign-Info");
-        var outputKey = hapCrypto.HKDF("sha512", accessorySalt, S_private, accessoryInfo, 32);
-        var serverLTPK = this.accessoryInfo.signPk;
-        var usernameData = Buffer.from(this.accessoryInfo.username);
-        var material = Buffer.concat([outputKey, usernameData, serverLTPK]);
-        var privateKey = Buffer.from(this.accessoryInfo.signSk);
-        var serverProof = tweetnacl_1.default.sign.detached(material, privateKey);
-        var message = tlv.encode(1 /* TLVValues.USERNAME */, usernameData, 3 /* TLVValues.PUBLIC_KEY */, serverLTPK, 10 /* TLVValues.PROOF */, serverProof);
-        var encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(hkdfEncKey, Buffer.from("PS-Msg06"), null, message);
+        const S_private = connection.srpServer.computeK();
+        const accessorySalt = Buffer.from("Pair-Setup-Accessory-Sign-Salt");
+        const accessoryInfo = Buffer.from("Pair-Setup-Accessory-Sign-Info");
+        const outputKey = hapCrypto.HKDF("sha512", accessorySalt, S_private, accessoryInfo, 32);
+        const serverLTPK = this.accessoryInfo.signPk;
+        const usernameData = Buffer.from(this.accessoryInfo.username);
+        const material = Buffer.concat([outputKey, usernameData, serverLTPK]);
+        const privateKey = Buffer.from(this.accessoryInfo.signSk);
+        const serverProof = tweetnacl_1.default.sign.detached(material, privateKey);
+        const message = tlv.encode(1 /* TLVValues.USERNAME */, usernameData, 3 /* TLVValues.PUBLIC_KEY */, serverLTPK, 10 /* TLVValues.PROOF */, serverProof);
+        const encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(hkdfEncKey, Buffer.from("PS-Msg06"), null, message);
         // finally, notify listeners that we have been paired with a client
-        this.emit("pair" /* HAPServerEventTypes.PAIR */, clientUsername.toString(), clientLTPK, (0, once_1.once)(function (err) {
+        this.emit("pair" /* HAPServerEventTypes.PAIR */, clientUsername.toString(), clientLTPK, (0, once_1.once)(err => {
             if (err) {
-                debug("[%s] Error adding pairing info: %s", _this.accessoryInfo.username, err.message);
+                debug("[%s] Error adding pairing info: %s", this.accessoryInfo.username, err.message);
                 response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
                 response.end(tlv.encode(6 /* TLVValues.SEQUENCE_NUM */, 6 /* PairingStates.M6 */, 7 /* TLVValues.ERROR_CODE */, 1 /* TLVErrorCode.UNKNOWN */));
                 connection._pairSetupState = undefined;
@@ -510,10 +492,10 @@ var HAPServer = /** @class */ (function (_super) {
             response.end(tlv.encode(6 /* TLVValues.SEQUENCE_NUM */, 6 /* PairingStates.M6 */, 5 /* TLVValues.ENCRYPTED_DATA */, Buffer.concat([encrypted.ciphertext, encrypted.authTag])));
             connection._pairSetupState = undefined;
         }));
-    };
-    HAPServer.prototype.handlePairVerify = function (connection, url, request, data, response) {
-        var tlvData = tlv.decode(data);
-        var sequence = tlvData[6 /* TLVValues.SEQUENCE_NUM */][0]; // value is single byte with sequence number
+    }
+    handlePairVerify(connection, url, request, data, response) {
+        const tlvData = tlv.decode(data);
+        const sequence = tlvData[6 /* TLVValues.SEQUENCE_NUM */][0]; // value is single byte with sequence number
         if (sequence === 1 /* PairingStates.M1 */) {
             this.handlePairVerifyM1(connection, request, response, tlvData);
         }
@@ -526,40 +508,40 @@ var HAPServer = /** @class */ (function (_super) {
             response.end(tlv.encode(6 /* TLVValues.STATE */, sequence + 1, 7 /* TLVValues.ERROR_CODE */, 1 /* TLVErrorCode.UNKNOWN */));
             return;
         }
-    };
-    HAPServer.prototype.handlePairVerifyM1 = function (connection, request, response, tlvData) {
+    }
+    handlePairVerifyM1(connection, request, response, tlvData) {
         debug("[%s] Pair verify step 1/2", this.accessoryInfo.username);
-        var clientPublicKey = tlvData[3 /* TLVValues.PUBLIC_KEY */]; // Buffer
+        const clientPublicKey = tlvData[3 /* TLVValues.PUBLIC_KEY */]; // Buffer
         // generate new encryption keys for this session
-        var keyPair = hapCrypto.generateCurve25519KeyPair();
-        var secretKey = Buffer.from(keyPair.secretKey);
-        var publicKey = Buffer.from(keyPair.publicKey);
-        var sharedSec = Buffer.from(hapCrypto.generateCurve25519SharedSecKey(secretKey, clientPublicKey));
-        var usernameData = Buffer.from(this.accessoryInfo.username);
-        var material = Buffer.concat([publicKey, usernameData, clientPublicKey]);
-        var privateKey = Buffer.from(this.accessoryInfo.signSk);
-        var serverProof = tweetnacl_1.default.sign.detached(material, privateKey);
-        var encSalt = Buffer.from("Pair-Verify-Encrypt-Salt");
-        var encInfo = Buffer.from("Pair-Verify-Encrypt-Info");
-        var outputKey = hapCrypto.HKDF("sha512", encSalt, sharedSec, encInfo, 32).slice(0, 32);
+        const keyPair = hapCrypto.generateCurve25519KeyPair();
+        const secretKey = Buffer.from(keyPair.secretKey);
+        const publicKey = Buffer.from(keyPair.publicKey);
+        const sharedSec = Buffer.from(hapCrypto.generateCurve25519SharedSecKey(secretKey, clientPublicKey));
+        const usernameData = Buffer.from(this.accessoryInfo.username);
+        const material = Buffer.concat([publicKey, usernameData, clientPublicKey]);
+        const privateKey = Buffer.from(this.accessoryInfo.signSk);
+        const serverProof = tweetnacl_1.default.sign.detached(material, privateKey);
+        const encSalt = Buffer.from("Pair-Verify-Encrypt-Salt");
+        const encInfo = Buffer.from("Pair-Verify-Encrypt-Info");
+        const outputKey = hapCrypto.HKDF("sha512", encSalt, sharedSec, encInfo, 32).slice(0, 32);
         connection.encryption = new eventedhttp_1.HAPEncryption(clientPublicKey, secretKey, publicKey, sharedSec, outputKey);
         // compose the response data in TLV format
-        var message = tlv.encode(1 /* TLVValues.USERNAME */, usernameData, 10 /* TLVValues.PROOF */, serverProof);
-        var encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(outputKey, Buffer.from("PV-Msg02"), null, message);
+        const message = tlv.encode(1 /* TLVValues.USERNAME */, usernameData, 10 /* TLVValues.PROOF */, serverProof);
+        const encrypted = hapCrypto.chacha20_poly1305_encryptAndSeal(outputKey, Buffer.from("PV-Msg02"), null, message);
         response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
         response.end(tlv.encode(6 /* TLVValues.SEQUENCE_NUM */, 2 /* PairingStates.M2 */, 5 /* TLVValues.ENCRYPTED_DATA */, Buffer.concat([encrypted.ciphertext, encrypted.authTag]), 3 /* TLVValues.PUBLIC_KEY */, publicKey));
         connection._pairVerifyState = 2 /* PairingStates.M2 */;
-    };
-    HAPServer.prototype.handlePairVerifyM3 = function (connection, request, response, objects) {
+    }
+    handlePairVerifyM3(connection, request, response, objects) {
         debug("[%s] Pair verify step 2/2", this.accessoryInfo.username);
-        var encryptedData = objects[5 /* TLVValues.ENCRYPTED_DATA */];
-        var messageData = Buffer.alloc(encryptedData.length - 16);
-        var authTagData = Buffer.alloc(16);
+        const encryptedData = objects[5 /* TLVValues.ENCRYPTED_DATA */];
+        const messageData = Buffer.alloc(encryptedData.length - 16);
+        const authTagData = Buffer.alloc(16);
         encryptedData.copy(messageData, 0, 0, encryptedData.length - 16);
         encryptedData.copy(authTagData, 0, encryptedData.length - 16, encryptedData.length);
         // instance of HAPEncryption (created in handlePairVerifyStepOne)
-        var enc = connection.encryption;
-        var plaintext;
+        const enc = connection.encryption;
+        let plaintext;
         try {
             plaintext = hapCrypto.chacha20_poly1305_decryptAndVerify(enc.hkdfPairEncryptionKey, Buffer.from("PV-Msg03"), null, messageData, authTagData);
         }
@@ -570,12 +552,12 @@ var HAPServer = /** @class */ (function (_super) {
             connection._pairVerifyState = undefined;
             return;
         }
-        var decoded = tlv.decode(plaintext);
-        var clientUsername = decoded[1 /* TLVValues.USERNAME */];
-        var proof = decoded[10 /* TLVValues.PROOF */];
-        var material = Buffer.concat([enc.clientPublicKey, clientUsername, enc.publicKey]);
+        const decoded = tlv.decode(plaintext);
+        const clientUsername = decoded[1 /* TLVValues.USERNAME */];
+        const proof = decoded[10 /* TLVValues.PROOF */];
+        const material = Buffer.concat([enc.clientPublicKey, clientUsername, enc.publicKey]);
         // since we're paired, we should have the public key stored for this client
-        var clientPublicKey = this.accessoryInfo.getClientPublicKey(clientUsername.toString());
+        const clientPublicKey = this.accessoryInfo.getClientPublicKey(clientUsername.toString());
         // if we're not actually paired, then there's nothing to verify - this client thinks it's paired with us, but we
         // disagree. Respond with invalid request (seems to match HomeKit Accessory Simulator behavior)
         if (!clientPublicKey) {
@@ -598,90 +580,89 @@ var HAPServer = /** @class */ (function (_super) {
         // now that the client has been verified, we must "upgrade" our pseudo-HTTP connection to include
         // TCP-level encryption. We'll do this by adding some more encryption vars to the session, and using them
         // in future calls to onEncrypt, onDecrypt.
-        var encSalt = Buffer.from("Control-Salt");
-        var infoRead = Buffer.from("Control-Read-Encryption-Key");
-        var infoWrite = Buffer.from("Control-Write-Encryption-Key");
+        const encSalt = Buffer.from("Control-Salt");
+        const infoRead = Buffer.from("Control-Read-Encryption-Key");
+        const infoWrite = Buffer.from("Control-Write-Encryption-Key");
         enc.accessoryToControllerKey = hapCrypto.HKDF("sha512", encSalt, enc.sharedSecret, infoRead, 32);
         enc.controllerToAccessoryKey = hapCrypto.HKDF("sha512", encSalt, enc.sharedSecret, infoWrite, 32);
         // Our connection is now completely setup. We now want to subscribe this connection to special
         connection.connectionAuthenticated(clientUsername.toString());
         connection._pairVerifyState = undefined;
-    };
-    HAPServer.prototype.handlePairings = function (connection, url, request, data, response) {
-        var _this = this;
+    }
+    handlePairings(connection, url, request, data, response) {
         // Only accept /pairing request if there is a secure session
         if (!this.allowInsecureRequest && !connection.isAuthenticated()) {
             response.writeHead(470 /* HAPPairingHTTPCode.CONNECTION_AUTHORIZATION_REQUIRED */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
             response.end(JSON.stringify({ status: -70401 /* HAPStatus.INSUFFICIENT_PRIVILEGES */ }));
             return;
         }
-        var objects = tlv.decode(data);
-        var method = objects[0 /* TLVValues.METHOD */][0]; // value is single byte with request type
-        var state = objects[6 /* TLVValues.STATE */][0];
+        const objects = tlv.decode(data);
+        const method = objects[0 /* TLVValues.METHOD */][0]; // value is single byte with request type
+        const state = objects[6 /* TLVValues.STATE */][0];
         if (state !== 1 /* PairingStates.M1 */) {
             return;
         }
         if (method === 3 /* PairMethods.ADD_PAIRING */) {
-            var identifier = objects[1 /* TLVValues.IDENTIFIER */].toString();
-            var publicKey = objects[3 /* TLVValues.PUBLIC_KEY */];
-            var permissions = objects[11 /* TLVValues.PERMISSIONS */][0];
-            this.emit("add-pairing" /* HAPServerEventTypes.ADD_PAIRING */, connection, identifier, publicKey, permissions, (0, once_1.once)(function (error) {
+            const identifier = objects[1 /* TLVValues.IDENTIFIER */].toString();
+            const publicKey = objects[3 /* TLVValues.PUBLIC_KEY */];
+            const permissions = objects[11 /* TLVValues.PERMISSIONS */][0];
+            this.emit("add-pairing" /* HAPServerEventTypes.ADD_PAIRING */, connection, identifier, publicKey, permissions, (0, once_1.once)((error) => {
                 if (error > 0) {
-                    debug("[%s] Pairings: failed ADD_PAIRING with code %d", _this.accessoryInfo.username, error);
+                    debug("[%s] Pairings: failed ADD_PAIRING with code %d", this.accessoryInfo.username, error);
                     response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
                     response.end(tlv.encode(6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */, 7 /* TLVValues.ERROR_CODE */, error));
                     return;
                 }
                 response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
                 response.end(tlv.encode(6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */));
-                debug("[%s] Pairings: successfully executed ADD_PAIRING", _this.accessoryInfo.username);
+                debug("[%s] Pairings: successfully executed ADD_PAIRING", this.accessoryInfo.username);
             }));
         }
         else if (method === 4 /* PairMethods.REMOVE_PAIRING */) {
-            var identifier = objects[1 /* TLVValues.IDENTIFIER */].toString();
-            this.emit("remove-pairing" /* HAPServerEventTypes.REMOVE_PAIRING */, connection, identifier, (0, once_1.once)(function (error) {
+            const identifier = objects[1 /* TLVValues.IDENTIFIER */].toString();
+            this.emit("remove-pairing" /* HAPServerEventTypes.REMOVE_PAIRING */, connection, identifier, (0, once_1.once)((error) => {
                 if (error > 0) {
-                    debug("[%s] Pairings: failed REMOVE_PAIRING with code %d", _this.accessoryInfo.username, error);
+                    debug("[%s] Pairings: failed REMOVE_PAIRING with code %d", this.accessoryInfo.username, error);
                     response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
                     response.end(tlv.encode(6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */, 7 /* TLVValues.ERROR_CODE */, error));
                     return;
                 }
                 response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
                 response.end(tlv.encode(6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */));
-                debug("[%s] Pairings: successfully executed REMOVE_PAIRING", _this.accessoryInfo.username);
+                debug("[%s] Pairings: successfully executed REMOVE_PAIRING", this.accessoryInfo.username);
             }));
         }
         else if (method === 5 /* PairMethods.LIST_PAIRINGS */) {
-            this.emit("list-pairings" /* HAPServerEventTypes.LIST_PAIRINGS */, connection, (0, once_1.once)(function (error, data) {
+            this.emit("list-pairings" /* HAPServerEventTypes.LIST_PAIRINGS */, connection, (0, once_1.once)((error, data) => {
                 if (error > 0) {
-                    debug("[%s] Pairings: failed LIST_PAIRINGS with code %d", _this.accessoryInfo.username, error);
+                    debug("[%s] Pairings: failed LIST_PAIRINGS with code %d", this.accessoryInfo.username, error);
                     response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" });
                     response.end(tlv.encode(6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */, 7 /* TLVValues.ERROR_CODE */, error));
                     return;
                 }
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                var tlvList = [];
-                data.forEach(function (value, index) {
+                const tlvList = [];
+                data.forEach((value, index) => {
                     if (index > 0) {
                         tlvList.push(255 /* TLVValues.SEPARATOR */, Buffer.alloc(0));
                     }
                     tlvList.push(1 /* TLVValues.IDENTIFIER */, value.username, 3 /* TLVValues.PUBLIC_KEY */, value.publicKey, 11 /* TLVValues.PERMISSIONS */, value.permission);
                 });
-                var list = tlv.encode.apply(tlv, tslib_1.__spreadArray([6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */], tslib_1.__read(tlvList), false));
+                const list = tlv.encode(6 /* TLVValues.STATE */, 2 /* PairingStates.M2 */, ...tlvList);
                 response.writeHead(200 /* HAPPairingHTTPCode.OK */, { "Content-Type": "application/pairing+tlv8" /* HAPMimeTypes.PAIRING_TLV8 */ });
                 response.end(list);
-                debug("[%s] Pairings: successfully executed LIST_PAIRINGS", _this.accessoryInfo.username);
+                debug("[%s] Pairings: successfully executed LIST_PAIRINGS", this.accessoryInfo.username);
             }));
         }
-    };
-    HAPServer.prototype.handleAccessories = function (connection, url, request, data, response) {
+    }
+    handleAccessories(connection, url, request, data, response) {
         if (!this.allowInsecureRequest && !connection.isAuthenticated()) {
             response.writeHead(470 /* HAPPairingHTTPCode.CONNECTION_AUTHORIZATION_REQUIRED */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
             response.end(JSON.stringify({ status: -70401 /* HAPStatus.INSUFFICIENT_PRIVILEGES */ }));
             return;
         }
         // call out to listeners to retrieve the latest accessories JSON
-        this.emit("accessories" /* HAPServerEventTypes.ACCESSORIES */, connection, (0, once_1.once)(function (error, result) {
+        this.emit("accessories" /* HAPServerEventTypes.ACCESSORIES */, connection, (0, once_1.once)((error, result) => {
             if (error) {
                 response.writeHead(error.httpCode, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                 response.end(JSON.stringify({ status: error.status }));
@@ -691,87 +672,55 @@ var HAPServer = /** @class */ (function (_super) {
                 response.end(JSON.stringify(result));
             }
         }));
-    };
-    HAPServer.prototype.handleCharacteristics = function (connection, url, request, data, response) {
-        var e_1, _a;
+    }
+    handleCharacteristics(connection, url, request, data, response) {
         if (!this.allowInsecureRequest && !connection.isAuthenticated()) {
             response.writeHead(470 /* HAPPairingHTTPCode.CONNECTION_AUTHORIZATION_REQUIRED */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
             response.end(JSON.stringify({ status: -70401 /* HAPStatus.INSUFFICIENT_PRIVILEGES */ }));
             return;
         }
         if (request.method === "GET") {
-            var searchParams = url.searchParams;
-            var idParam = searchParams.get("id");
+            const searchParams = url.searchParams;
+            const idParam = searchParams.get("id");
             if (!idParam) {
                 response.writeHead(400 /* HAPHTTPCode.BAD_REQUEST */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                 response.end(JSON.stringify({ status: -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */ }));
                 return;
             }
-            var ids = [];
-            try {
-                for (var _b = tslib_1.__values(idParam.split(",")), _c = _b.next(); !_c.done; _c = _b.next()) { // ["1.9","2.14"]
-                    var entry = _c.value;
-                    var split = entry.split("."); // ["1","9"]
-                    ids.push({
-                        aid: parseInt(split[0], 10), // accessory id
-                        iid: parseInt(split[1], 10), // (characteristic) instance id
-                    });
-                }
-            }
-            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; }
+            const ids = [];
+            for (const entry of idParam.split(",")) { // ["1.9","2.14"]
+                const split = entry.split("."); // ["1","9"]
+                ids.push({
+                    aid: parseInt(split[0], 10), // accessory id
+                    iid: parseInt(split[1], 10), // (characteristic) instance id
+                });
             }
-            var readRequest = {
+            const readRequest = {
                 ids: ids,
                 includeMeta: (0, internal_types_1.consideredTrue)(searchParams.get("meta")),
                 includePerms: (0, internal_types_1.consideredTrue)(searchParams.get("perms")),
                 includeType: (0, internal_types_1.consideredTrue)(searchParams.get("type")),
                 includeEvent: (0, internal_types_1.consideredTrue)(searchParams.get("ev")),
             };
-            this.emit("get-characteristics" /* HAPServerEventTypes.GET_CHARACTERISTICS */, connection, readRequest, (0, once_1.once)(function (error, readResponse) {
-                var e_2, _a, e_3, _b;
+            this.emit("get-characteristics" /* HAPServerEventTypes.GET_CHARACTERISTICS */, connection, readRequest, (0, once_1.once)((error, readResponse) => {
                 if (error) {
                     response.writeHead(error.httpCode, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                     response.end(JSON.stringify({ status: error.status }));
                     return;
                 }
-                var characteristics = readResponse.characteristics;
-                var errorOccurred = false; // determine if we send a 207 Multi-Status
-                try {
-                    for (var characteristics_1 = tslib_1.__values(characteristics), characteristics_1_1 = characteristics_1.next(); !characteristics_1_1.done; characteristics_1_1 = characteristics_1.next()) {
-                        var data_1 = characteristics_1_1.value;
-                        if (data_1.status) {
-                            errorOccurred = true;
-                            break;
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (characteristics_1_1 && !characteristics_1_1.done && (_a = characteristics_1.return)) _a.call(characteristics_1);
+                const characteristics = readResponse.characteristics;
+                let errorOccurred = false; // determine if we send a 207 Multi-Status
+                for (const data of characteristics) {
+                    if (data.status) {
+                        errorOccurred = true;
+                        break;
                     }
-                    finally { if (e_2) throw e_2.error; }
                 }
                 if (errorOccurred) { // on a 207 Multi-Status EVERY characteristic MUST include a status property
-                    try {
-                        for (var characteristics_2 = tslib_1.__values(characteristics), characteristics_2_1 = characteristics_2.next(); !characteristics_2_1.done; characteristics_2_1 = characteristics_2.next()) {
-                            var data_2 = characteristics_2_1.value;
-                            if (!data_2.status) { // a status is undefined if the request was successful
-                                data_2.status = 0 /* HAPStatus.SUCCESS */; // a value of zero indicates success
-                            }
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (characteristics_2_1 && !characteristics_2_1.done && (_b = characteristics_2.return)) _b.call(characteristics_2);
+                    for (const data of characteristics) {
+                        if (!data.status) { // a status is undefined if the request was successful
+                            data.status = 0 /* HAPStatus.SUCCESS */; // a value of zero indicates success
                         }
-                        finally { if (e_3) throw e_3.error; }
                     }
                 }
                 // 207 "multi-status" is returned when an error occurs reading a characteristic. otherwise 200 is returned
@@ -792,33 +741,22 @@ var HAPServer = /** @class */ (function (_super) {
                 response.end(JSON.stringify({ status: -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */ }));
                 return;
             }
-            var writeRequest = JSON.parse(data.toString("utf8"));
-            this.emit("set-characteristics" /* HAPServerEventTypes.SET_CHARACTERISTICS */, connection, writeRequest, (0, once_1.once)(function (error, writeResponse) {
-                var e_4, _a;
+            const writeRequest = JSON.parse(data.toString("utf8"));
+            this.emit("set-characteristics" /* HAPServerEventTypes.SET_CHARACTERISTICS */, connection, writeRequest, (0, once_1.once)((error, writeResponse) => {
                 if (error) {
                     response.writeHead(error.httpCode, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                     response.end(JSON.stringify({ status: error.status }));
                     return;
                 }
-                var characteristics = writeResponse.characteristics;
-                var multiStatus = false;
-                try {
-                    for (var characteristics_3 = tslib_1.__values(characteristics), characteristics_3_1 = characteristics_3.next(); !characteristics_3_1.done; characteristics_3_1 = characteristics_3.next()) {
-                        var data_3 = characteristics_3_1.value;
-                        if (data_3.status || data_3.value !== undefined) {
-                            // also send multiStatus on write response requests
-                            multiStatus = true;
-                            break;
-                        }
+                const characteristics = writeResponse.characteristics;
+                let multiStatus = false;
+                for (const data of characteristics) {
+                    if (data.status || data.value !== undefined) {
+                        // also send multiStatus on write response requests
+                        multiStatus = true;
+                        break;
                     }
                 }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
-                    try {
-                        if (characteristics_3_1 && !characteristics_3_1.done && (_a = characteristics_3.return)) _a.call(characteristics_3);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                }
                 if (multiStatus) {
                     // 207 is "multi-status" since HomeKit may be setting multiple things and any one can fail independently
                     response.writeHead(207 /* HAPHTTPCode.MULTI_STATUS */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
@@ -835,9 +773,8 @@ var HAPServer = /** @class */ (function (_super) {
             response.writeHead(400 /* HAPHTTPCode.BAD_REQUEST */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ }); // method not allowed
             response.end(JSON.stringify({ status: -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */ }));
         }
-    };
-    HAPServer.prototype.handlePrepareWrite = function (connection, url, request, data, response) {
-        var _this = this;
+    }
+    handlePrepareWrite(connection, url, request, data, response) {
         if (!this.allowInsecureRequest && !connection.isAuthenticated()) {
             response.writeHead(470 /* HAPPairingHTTPCode.CONNECTION_AUTHORIZATION_REQUIRED */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
             response.end(JSON.stringify({ status: -70401 /* HAPStatus.INSUFFICIENT_PRIVILEGES */ }));
@@ -849,18 +786,18 @@ var HAPServer = /** @class */ (function (_super) {
                 response.end(JSON.stringify({ status: -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */ }));
                 return;
             }
-            var prepareRequest_1 = JSON.parse(data.toString());
-            if (prepareRequest_1.pid && prepareRequest_1.ttl) {
-                debug("[%s] Received prepare write request with pid %d and ttl %d", this.accessoryInfo.username, prepareRequest_1.pid, prepareRequest_1.ttl);
+            const prepareRequest = JSON.parse(data.toString());
+            if (prepareRequest.pid && prepareRequest.ttl) {
+                debug("[%s] Received prepare write request with pid %d and ttl %d", this.accessoryInfo.username, prepareRequest.pid, prepareRequest.ttl);
                 if (connection.timedWriteTimeout) { // clear any currently existing timeouts
                     clearTimeout(connection.timedWriteTimeout);
                 }
-                connection.timedWritePid = prepareRequest_1.pid;
-                connection.timedWriteTimeout = setTimeout(function () {
-                    debug("[%s] Timed write request timed out for pid %d", _this.accessoryInfo.username, prepareRequest_1.pid);
+                connection.timedWritePid = prepareRequest.pid;
+                connection.timedWriteTimeout = setTimeout(() => {
+                    debug("[%s] Timed write request timed out for pid %d", this.accessoryInfo.username, prepareRequest.pid);
                     connection.timedWritePid = undefined;
                     connection.timedWriteTimeout = undefined;
-                }, prepareRequest_1.ttl);
+                }, prepareRequest.ttl);
                 response.writeHead(200 /* HAPHTTPCode.OK */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                 response.end(JSON.stringify({ status: 0 /* HAPStatus.SUCCESS */ }));
                 return;
@@ -874,8 +811,8 @@ var HAPServer = /** @class */ (function (_super) {
             response.writeHead(400 /* HAPHTTPCode.BAD_REQUEST */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
             response.end(JSON.stringify({ status: -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */ }));
         }
-    };
-    HAPServer.prototype.handleResource = function (connection, url, request, data, response) {
+    }
+    handleResource(connection, url, request, data, response) {
         if (!connection.isAuthenticated()) {
             if (!(this.allowInsecureRequest && request.headers && request.headers.authorization === this.accessoryInfo.pincode)) {
                 response.writeHead(470 /* HAPPairingHTTPCode.CONNECTION_AUTHORIZATION_REQUIRED */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
@@ -889,9 +826,9 @@ var HAPServer = /** @class */ (function (_super) {
                 response.end(JSON.stringify({ status: -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */ }));
                 return;
             }
-            var resourceRequest = JSON.parse(data.toString());
+            const resourceRequest = JSON.parse(data.toString());
             // call out to listeners to retrieve the resource, snapshot only right now
-            this.emit("request-resource" /* HAPServerEventTypes.REQUEST_RESOURCE */, resourceRequest, (0, once_1.once)(function (error, resource) {
+            this.emit("request-resource" /* HAPServerEventTypes.REQUEST_RESOURCE */, resourceRequest, (0, once_1.once)((error, resource) => {
                 if (error) {
                     response.writeHead(error.httpCode, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ });
                     response.end(JSON.stringify({ status: error.status }));
@@ -906,8 +843,7 @@ var HAPServer = /** @class */ (function (_super) {
             response.writeHead(400 /* HAPHTTPCode.BAD_REQUEST */, { "Content-Type": "application/hap+json" /* HAPMimeTypes.HAP_JSON */ }); // method not allowed
             response.end(JSON.stringify({ status: -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */ }));
         }
-    };
-    return HAPServer;
-}(events_1.EventEmitter));
+    }
+}
 exports.HAPServer = HAPServer;
 //# sourceMappingURL=HAPServer.js.map