hap-nodejs 0.12.3-beta.11 → 0.12.3-beta.13

package/dist/lib/controller/RemoteController.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SiriAudioSession = exports.SiriAudioSessionEvents = exports.HomeKitRemoteController = exports.RemoteController = exports.RemoteControllerEvents = exports.TargetUpdates = exports.AudioCodecTypes = exports.ButtonState = exports.TargetCategory = exports.ButtonType = void 0;
-var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var debug_1 = tslib_1.__importDefault(require("debug"));
-var events_1 = require("events");
-var Characteristic_1 = require("../Characteristic");
-var datastream_1 = require("../datastream");
-var Service_1 = require("../Service");
-var tlv = tslib_1.__importStar(require("../util/tlv"));
-var debug = (0, debug_1.default)("HAP-NodeJS:Remote:Controller");
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const events_1 = require("events");
+const Characteristic_1 = require("../Characteristic");
+const datastream_1 = require("../datastream");
+const Service_1 = require("../Service");
+const tlv = tslib_1.__importStar(require("../util/tlv"));
+const debug = (0, debug_1.default)("HAP-NodeJS:Remote:Controller");
 var TargetControlCommands;
 (function (TargetControlCommands) {
     TargetControlCommands[TargetControlCommands["MAXIMUM_TARGETS"] = 1] = "MAXIMUM_TARGETS";
@@ -193,8 +193,39 @@ var RemoteControllerEvents;
  * @group Apple TV Remote
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-var RemoteController = /** @class */ (function (_super) {
-    tslib_1.__extends(RemoteController, _super);
+class RemoteController extends events_1.EventEmitter {
+    stateChangeDelegate;
+    audioSupported;
+    audioProducerConstructor;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    audioProducerOptions;
+    targetControlManagementService;
+    targetControlService;
+    siriService;
+    audioStreamManagementService;
+    dataStreamManagement;
+    buttons = {}; // internal mapping of buttonId to buttonType for supported buttons
+    supportedConfiguration;
+    targetConfigurations = new Map();
+    targetConfigurationsString = "";
+    lastButtonEvent = "";
+    activeIdentifier = 0; // id of 0 means no device selected
+    activeConnection; // session which marked this remote as active and listens for events and siri
+    activeConnectionDisconnectListener;
+    supportedAudioConfiguration;
+    selectedAudioConfiguration;
+    selectedAudioConfigurationString;
+    dataStreamConnections = new Map(); // maps targetIdentifiers to active data stream connections
+    activeAudioSession;
+    nextAudioSession;
+    /**
+     * @private
+     */
+    eventHandler;
+    /**
+     * @private
+     */
+    requestHandler;
     /**
      * Creates a new RemoteController.
      * If siri voice input is supported the constructor to an SiriAudioStreamProducer needs to be supplied.
@@ -207,22 +238,16 @@ var RemoteController = /** @class */ (function (_super) {
      *                          constructor. This should be used to supply configurations to the stream producer.
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
-    function RemoteController(audioProducerConstructor, producerOptions) {
-        var _this = _super.call(this) || this;
-        _this.buttons = {}; // internal mapping of buttonId to buttonType for supported buttons
-        _this.targetConfigurations = new Map();
-        _this.targetConfigurationsString = "";
-        _this.lastButtonEvent = "";
-        _this.activeIdentifier = 0; // id of 0 means no device selected
-        _this.dataStreamConnections = new Map(); // maps targetIdentifiers to active data stream connections
-        _this.audioSupported = audioProducerConstructor !== undefined;
-        _this.audioProducerConstructor = audioProducerConstructor;
-        _this.audioProducerOptions = producerOptions;
-        var configuration = _this.constructSupportedConfiguration();
-        _this.supportedConfiguration = _this.buildTargetControlSupportedConfigurationTLV(configuration);
-        var audioConfiguration = _this.constructSupportedAudioConfiguration();
-        _this.supportedAudioConfiguration = RemoteController.buildSupportedAudioConfigurationTLV(audioConfiguration);
-        _this.selectedAudioConfiguration = {
+    constructor(audioProducerConstructor, producerOptions) {
+        super();
+        this.audioSupported = audioProducerConstructor !== undefined;
+        this.audioProducerConstructor = audioProducerConstructor;
+        this.audioProducerOptions = producerOptions;
+        const configuration = this.constructSupportedConfiguration();
+        this.supportedConfiguration = this.buildTargetControlSupportedConfigurationTLV(configuration);
+        const audioConfiguration = this.constructSupportedAudioConfiguration();
+        this.supportedAudioConfiguration = RemoteController.buildSupportedAudioConfigurationTLV(audioConfiguration);
+        this.selectedAudioConfiguration = {
             codecType: 3 /* AudioCodecTypes.OPUS */,
             parameters: {
                 channels: 1,
@@ -231,24 +256,22 @@ var RemoteController = /** @class */ (function (_super) {
                 rtpTime: 20,
             },
         };
-        _this.selectedAudioConfigurationString = RemoteController.buildSelectedAudioConfigurationTLV({
-            audioCodecConfiguration: _this.selectedAudioConfiguration,
+        this.selectedAudioConfigurationString = RemoteController.buildSelectedAudioConfigurationTLV({
+            audioCodecConfiguration: this.selectedAudioConfiguration,
         });
-        return _this;
     }
     /**
      * @private
      */
-    RemoteController.prototype.controllerId = function () {
+    controllerId() {
         return "remote" /* DefaultControllerType.REMOTE */;
-    };
+    }
     /**
      * Set a new target as active target. A value of 0 indicates that no target is selected currently.
      *
      * @param activeIdentifier - target identifier
      */
-    RemoteController.prototype.setActiveIdentifier = function (activeIdentifier) {
-        var _this = this;
+    setActiveIdentifier(activeIdentifier) {
         if (activeIdentifier === this.activeIdentifier) {
             return;
         }
@@ -261,96 +284,82 @@ var RemoteController = /** @class */ (function (_super) {
         if (this.activeAudioSession) {
             this.handleSiriAudioStop();
         }
-        setTimeout(function () { return _this.emit("active-identifier-change" /* RemoteControllerEvents.ACTIVE_IDENTIFIER_CHANGE */, activeIdentifier); }, 0);
+        setTimeout(() => this.emit("active-identifier-change" /* RemoteControllerEvents.ACTIVE_IDENTIFIER_CHANGE */, activeIdentifier), 0);
         this.setInactive();
-    };
+    }
     /**
      * @returns if the current target is active, meaning the active device is listening for button events or audio sessions
      */
-    RemoteController.prototype.isActive = function () {
+    isActive() {
         return !!this.activeConnection;
-    };
+    }
     /**
      * Checks if the supplied targetIdentifier is configured.
      *
      * @param targetIdentifier - The target identifier.
      */
-    RemoteController.prototype.isConfigured = function (targetIdentifier) {
+    isConfigured(targetIdentifier) {
         return this.targetConfigurations.has(targetIdentifier);
-    };
+    }
     /**
      * Returns the targetIdentifier for a give device name
      *
      * @param name - The name of the device.
      * @returns The targetIdentifier of the device or undefined if not existent.
      */
-    RemoteController.prototype.getTargetIdentifierByName = function (name) {
-        var e_1, _a;
-        try {
-            for (var _b = tslib_1.__values(Object.entries(this.targetConfigurations)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = tslib_1.__read(_c.value, 2), activeIdentifier = _d[0], configuration = _d[1];
-                if (configuration.targetName === name) {
-                    return parseInt(activeIdentifier, 10);
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+    getTargetIdentifierByName(name) {
+        for (const [activeIdentifier, configuration] of Object.entries(this.targetConfigurations)) {
+            if (configuration.targetName === name) {
+                return parseInt(activeIdentifier, 10);
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return undefined;
-    };
+    }
     /**
      * Sends a button event to press the supplied button.
      *
      * @param button - button to be pressed
      */
-    RemoteController.prototype.pushButton = function (button) {
+    pushButton(button) {
         this.sendButtonEvent(button, 1 /* ButtonState.DOWN */);
-    };
+    }
     /**
      * Sends a button event that the supplied button was released.
      *
      * @param button - button which was released
      */
-    RemoteController.prototype.releaseButton = function (button) {
+    releaseButton(button) {
         this.sendButtonEvent(button, 0 /* ButtonState.UP */);
-    };
+    }
     /**
      * Presses a supplied button for a given time.
      *
      * @param button - button to be pressed and released
      * @param time - time in milliseconds (defaults to 200ms)
      */
-    RemoteController.prototype.pushAndReleaseButton = function (button, time) {
-        var _this = this;
-        if (time === void 0) { time = 200; }
+    pushAndReleaseButton(button, time = 200) {
         this.pushButton(button);
-        setTimeout(function () { return _this.releaseButton(button); }, time);
-    };
+        setTimeout(() => this.releaseButton(button), time);
+    }
     /**
      * This method adds and configures the remote services for a give accessory.
      *
      * @param accessory - the give accessory this remote should be added to
      * @deprecated - use {@link Accessory.configureController} instead
      */
-    RemoteController.prototype.addServicesToAccessory = function (accessory) {
+    addServicesToAccessory(accessory) {
         accessory.configureController(this);
-    };
+    }
     // ---------------------------------- CONFIGURATION ----------------------------------
     // override methods if you would like to change anything (but should not be necessary most likely)
-    RemoteController.prototype.constructSupportedConfiguration = function () {
-        var _this = this;
-        var configuration = {
+    constructSupportedConfiguration() {
+        const configuration = {
             maximumTargets: 10, // some random number. (ten should be okay?)
             ticksPerSecond: 1000, // we rely on unix timestamps
             supportedButtonConfiguration: [],
             hardwareImplemented: this.audioSupported, // siri is only allowed for hardware implemented remotes
         };
-        var supportedButtons = [
+        const supportedButtons = [
             1 /* ButtonType.MENU */, 2 /* ButtonType.PLAY_PAUSE */, 3 /* ButtonType.TV_HOME */, 4 /* ButtonType.SELECT */,
             5 /* ButtonType.ARROW_UP */, 6 /* ButtonType.ARROW_RIGHT */, 7 /* ButtonType.ARROW_DOWN */, 8 /* ButtonType.ARROW_LEFT */,
             9 /* ButtonType.VOLUME_UP */, 10 /* ButtonType.VOLUME_DOWN */, 12 /* ButtonType.POWER */, 13 /* ButtonType.GENERIC */,
@@ -358,17 +367,17 @@ var RemoteController = /** @class */ (function (_super) {
         if (this.audioSupported) { // add siri button if this remote supports it
             supportedButtons.push(11 /* ButtonType.SIRI */);
         }
-        supportedButtons.forEach(function (button) {
-            var buttonConfiguration = {
+        supportedButtons.forEach(button => {
+            const buttonConfiguration = {
                 buttonID: 100 + button,
                 buttonType: button,
             };
             configuration.supportedButtonConfiguration.push(buttonConfiguration);
-            _this.buttons[button] = buttonConfiguration.buttonID; // also saving mapping of type to id locally
+            this.buttons[button] = buttonConfiguration.buttonID; // also saving mapping of type to id locally
         });
         return configuration;
-    };
-    RemoteController.prototype.constructSupportedAudioConfiguration = function () {
+    }
+    constructSupportedAudioConfiguration() {
         // the following parameters are expected from HomeKit for a remote
         return {
             audioCodecConfiguration: {
@@ -380,19 +389,19 @@ var RemoteController = /** @class */ (function (_super) {
                 },
             },
         };
-    };
+    }
     // --------------------------------- TARGET CONTROL ----------------------------------
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    RemoteController.prototype.handleTargetControlWrite = function (value, callback) {
-        var data = Buffer.from(value, "base64");
-        var objects = tlv.decode(data);
-        var operation = objects[1 /* TargetControlList.OPERATION */][0];
-        var targetConfiguration = undefined;
+    handleTargetControlWrite(value, callback) {
+        const data = Buffer.from(value, "base64");
+        const objects = tlv.decode(data);
+        const operation = objects[1 /* TargetControlList.OPERATION */][0];
+        let targetConfiguration = undefined;
         if (objects[2 /* TargetControlList.TARGET_CONFIGURATION */]) { // if target configuration was sent, parse it
             targetConfiguration = this.parseTargetConfigurationTLV(objects[2 /* TargetControlList.TARGET_CONFIGURATION */]);
         }
         debug("Received TargetControl write operation %s", Operation[operation]);
-        var handler;
+        let handler;
         switch (operation) {
             case Operation.ADD:
                 handler = this.handleAddTarget.bind(this);
@@ -413,7 +422,7 @@ var RemoteController = /** @class */ (function (_super) {
                 callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */, undefined);
                 return;
         }
-        var status = handler(targetConfiguration);
+        const status = handler(targetConfiguration);
         if (status === 0 /* HAPStatus.SUCCESS */) {
             callback(undefined, this.targetConfigurationsString); // passing value for write response
             if (operation === Operation.ADD && this.activeIdentifier === 0) {
@@ -423,26 +432,23 @@ var RemoteController = /** @class */ (function (_super) {
         else {
             callback(new Error(status + ""));
         }
-    };
-    RemoteController.prototype.handleAddTarget = function (targetConfiguration) {
-        var _this = this;
+    }
+    handleAddTarget(targetConfiguration) {
         if (!targetConfiguration) {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
         this.targetConfigurations.set(targetConfiguration.targetIdentifier, targetConfiguration);
         debug("Configured new target '" + targetConfiguration.targetName + "' with targetIdentifier '" + targetConfiguration.targetIdentifier + "'");
-        setTimeout(function () { return _this.emit("target-add" /* RemoteControllerEvents.TARGET_ADDED */, targetConfiguration); }, 0);
+        setTimeout(() => this.emit("target-add" /* RemoteControllerEvents.TARGET_ADDED */, targetConfiguration), 0);
         this.updatedTargetConfiguration(); // set response
         return 0 /* HAPStatus.SUCCESS */;
-    };
-    RemoteController.prototype.handleUpdateTarget = function (targetConfiguration) {
-        var e_2, _a;
-        var _this = this;
+    }
+    handleUpdateTarget(targetConfiguration) {
         if (!targetConfiguration) {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
-        var updates = [];
-        var configuredTarget = this.targetConfigurations.get(targetConfiguration.targetIdentifier);
+        const updates = [];
+        const configuredTarget = this.targetConfigurations.get(targetConfiguration.targetIdentifier);
         if (!configuredTarget) {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
@@ -458,76 +464,64 @@ var RemoteController = /** @class */ (function (_super) {
         }
         if (targetConfiguration.buttonConfiguration) {
             debug("%d button configurations were updated for target '%s' (%d)", Object.keys(targetConfiguration.buttonConfiguration).length, configuredTarget.targetName, configuredTarget.targetIdentifier);
-            try {
-                for (var _b = tslib_1.__values(Object.values(targetConfiguration.buttonConfiguration)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var configuration = _c.value;
-                    var savedConfiguration = configuredTarget.buttonConfiguration[configuration.buttonID];
-                    savedConfiguration.buttonType = configuration.buttonType;
-                    savedConfiguration.buttonName = configuration.buttonName;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_2) throw e_2.error; }
+            for (const configuration of Object.values(targetConfiguration.buttonConfiguration)) {
+                const savedConfiguration = configuredTarget.buttonConfiguration[configuration.buttonID];
+                savedConfiguration.buttonType = configuration.buttonType;
+                savedConfiguration.buttonName = configuration.buttonName;
             }
             updates.push(2 /* TargetUpdates.UPDATED_BUTTONS */);
         }
-        setTimeout(function () { return _this.emit("target-update" /* RemoteControllerEvents.TARGET_UPDATED */, targetConfiguration, updates); }, 0);
+        setTimeout(() => this.emit("target-update" /* RemoteControllerEvents.TARGET_UPDATED */, targetConfiguration, updates), 0);
         this.updatedTargetConfiguration(); // set response
         return 0 /* HAPStatus.SUCCESS */;
-    };
-    RemoteController.prototype.handleRemoveTarget = function (targetConfiguration) {
-        var _this = this;
+    }
+    handleRemoveTarget(targetConfiguration) {
         if (!targetConfiguration) {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
-        var configuredTarget = this.targetConfigurations.get(targetConfiguration.targetIdentifier);
+        const configuredTarget = this.targetConfigurations.get(targetConfiguration.targetIdentifier);
         if (!configuredTarget) {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
         if (targetConfiguration.buttonConfiguration) {
-            for (var key in targetConfiguration.buttonConfiguration) {
+            for (const key in targetConfiguration.buttonConfiguration) {
                 if (Object.prototype.hasOwnProperty.call(targetConfiguration.buttonConfiguration, key)) {
                     delete configuredTarget.buttonConfiguration[key];
                 }
             }
             debug("Removed %d button configurations of target '%s' (%d)", Object.keys(targetConfiguration.buttonConfiguration).length, configuredTarget.targetName, configuredTarget.targetIdentifier);
-            setTimeout(function () { return _this.emit("target-update" /* RemoteControllerEvents.TARGET_UPDATED */, configuredTarget, [3 /* TargetUpdates.REMOVED_BUTTONS */]); }, 0);
+            setTimeout(() => this.emit("target-update" /* RemoteControllerEvents.TARGET_UPDATED */, configuredTarget, [3 /* TargetUpdates.REMOVED_BUTTONS */]), 0);
         }
         else {
             this.targetConfigurations.delete(targetConfiguration.targetIdentifier);
             debug("Target '%s' (%d) was removed", configuredTarget.targetName, configuredTarget.targetIdentifier);
-            setTimeout(function () { return _this.emit("target-remove" /* RemoteControllerEvents.TARGET_REMOVED */, targetConfiguration.targetIdentifier); }, 0);
-            var keys = Object.keys(this.targetConfigurations);
+            setTimeout(() => this.emit("target-remove" /* RemoteControllerEvents.TARGET_REMOVED */, targetConfiguration.targetIdentifier), 0);
+            const keys = Object.keys(this.targetConfigurations);
             this.setActiveIdentifier(keys.length === 0 ? 0 : parseInt(keys[0], 10)); // switch to next available remote
         }
         this.updatedTargetConfiguration(); // set response
         return 0 /* HAPStatus.SUCCESS */;
-    };
-    RemoteController.prototype.handleResetTargets = function (targetConfiguration) {
-        var _this = this;
+    }
+    handleResetTargets(targetConfiguration) {
         if (targetConfiguration) {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
         debug("Resetting all target configurations");
         this.targetConfigurations = new Map();
         this.updatedTargetConfiguration(); // set response
-        setTimeout(function () { return _this.emit("targets-reset" /* RemoteControllerEvents.TARGETS_RESET */); }, 0);
+        setTimeout(() => this.emit("targets-reset" /* RemoteControllerEvents.TARGETS_RESET */), 0);
         this.setActiveIdentifier(0); // resetting active identifier (also sets active to false)
         return 0 /* HAPStatus.SUCCESS */;
-    };
-    RemoteController.prototype.handleListTargets = function (targetConfiguration) {
+    }
+    handleListTargets(targetConfiguration) {
         if (targetConfiguration) {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
         // this.targetConfigurationsString is updated after each change, so we basically don't need to do anything here
         debug("Returning " + Object.keys(this.targetConfigurations).length + " target configurations");
         return 0 /* HAPStatus.SUCCESS */;
-    };
-    RemoteController.prototype.handleActiveWrite = function (value, callback, connection) {
+    }
+    handleActiveWrite(value, callback, connection) {
         if (this.activeIdentifier === 0) {
             debug("Tried to change active state. There is no active target set though");
             callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
@@ -543,7 +537,7 @@ var RemoteController = /** @class */ (function (_super) {
             this.activeConnectionDisconnectListener = this.handleActiveSessionDisconnected.bind(this, this.activeConnection);
             this.activeConnection.on("closed" /* HAPConnectionEvent.CLOSED */, this.activeConnectionDisconnectListener);
         }
-        var activeTarget = this.targetConfigurations.get(this.activeIdentifier);
+        const activeTarget = this.targetConfigurations.get(this.activeIdentifier);
         if (!activeTarget) {
             callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
             return;
@@ -551,9 +545,8 @@ var RemoteController = /** @class */ (function (_super) {
         debug("Remote with activeTarget '%s' (%d) was set to %s", activeTarget.targetName, this.activeIdentifier, value ? "ACTIVE" : "INACTIVE");
         callback();
         this.emit("active-change" /* RemoteControllerEvents.ACTIVE_CHANGE */, value);
-    };
-    RemoteController.prototype.setInactive = function () {
-        var _this = this;
+    }
+    setInactive() {
         if (this.activeConnection === undefined) {
             return;
         }
@@ -562,17 +555,17 @@ var RemoteController = /** @class */ (function (_super) {
         this.activeConnectionDisconnectListener = undefined;
         this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.Active).updateValue(false);
         debug("Remote was set to INACTIVE");
-        setTimeout(function () { return _this.emit("active-change" /* RemoteControllerEvents.ACTIVE_CHANGE */, false); }, 0);
-    };
-    RemoteController.prototype.handleActiveSessionDisconnected = function (connection) {
+        setTimeout(() => this.emit("active-change" /* RemoteControllerEvents.ACTIVE_CHANGE */, false), 0);
+    }
+    handleActiveSessionDisconnected(connection) {
         if (connection !== this.activeConnection) {
             return;
         }
         debug("Active hap session disconnected!");
         this.setInactive();
-    };
-    RemoteController.prototype.sendButtonEvent = function (button, buttonState) {
-        var buttonID = this.buttons[button];
+    }
+    sendButtonEvent(button, buttonState) {
+        const buttonID = this.buttons[button];
         if (buttonID === undefined || buttonID === 0) {
             throw new Error("Tried sending button event for unsupported button (" + button + ")");
         }
@@ -591,33 +584,33 @@ var RemoteController = /** @class */ (function (_super) {
             }
             return;
         }
-        var buttonIdTlv = tlv.encode(1 /* ButtonEvent.BUTTON_ID */, buttonID);
-        var buttonStateTlv = tlv.encode(2 /* ButtonEvent.BUTTON_STATE */, buttonState);
-        var timestampTlv = tlv.encode(3 /* ButtonEvent.TIMESTAMP */, tlv.writeVariableUIntLE(new Date().getTime()));
-        var activeIdentifierTlv = tlv.encode(4 /* ButtonEvent.ACTIVE_IDENTIFIER */, tlv.writeUInt32(this.activeIdentifier));
+        const buttonIdTlv = tlv.encode(1 /* ButtonEvent.BUTTON_ID */, buttonID);
+        const buttonStateTlv = tlv.encode(2 /* ButtonEvent.BUTTON_STATE */, buttonState);
+        const timestampTlv = tlv.encode(3 /* ButtonEvent.TIMESTAMP */, tlv.writeVariableUIntLE(new Date().getTime()));
+        const activeIdentifierTlv = tlv.encode(4 /* ButtonEvent.ACTIVE_IDENTIFIER */, tlv.writeUInt32(this.activeIdentifier));
         this.lastButtonEvent = Buffer.concat([
             buttonIdTlv, buttonStateTlv, timestampTlv, activeIdentifierTlv,
         ]).toString("base64");
         this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ButtonEvent).sendEventNotification(this.lastButtonEvent);
-    };
-    RemoteController.prototype.parseTargetConfigurationTLV = function (data) {
-        var configTLV = tlv.decode(data);
-        var identifier = tlv.readUInt32(configTLV[1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */]);
-        var name = undefined;
+    }
+    parseTargetConfigurationTLV(data) {
+        const configTLV = tlv.decode(data);
+        const identifier = tlv.readUInt32(configTLV[1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */]);
+        let name = undefined;
         if (configTLV[2 /* TargetConfigurationTypes.TARGET_NAME */]) {
             name = configTLV[2 /* TargetConfigurationTypes.TARGET_NAME */].toString();
         }
-        var category = undefined;
+        let category = undefined;
         if (configTLV[3 /* TargetConfigurationTypes.TARGET_CATEGORY */]) {
             category = tlv.readUInt16(configTLV[3 /* TargetConfigurationTypes.TARGET_CATEGORY */]);
         }
-        var buttonConfiguration = {};
+        const buttonConfiguration = {};
         if (configTLV[4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */]) {
-            var buttonConfigurationTLV = tlv.decodeList(configTLV[4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */], 1 /* ButtonConfigurationTypes.BUTTON_ID */);
-            buttonConfigurationTLV.forEach(function (entry) {
-                var buttonId = entry[1 /* ButtonConfigurationTypes.BUTTON_ID */][0];
-                var buttonType = tlv.readUInt16(entry[2 /* ButtonConfigurationTypes.BUTTON_TYPE */]);
-                var buttonName;
+            const buttonConfigurationTLV = tlv.decodeList(configTLV[4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */], 1 /* ButtonConfigurationTypes.BUTTON_ID */);
+            buttonConfigurationTLV.forEach(entry => {
+                const buttonId = entry[1 /* ButtonConfigurationTypes.BUTTON_ID */][0];
+                const buttonType = tlv.readUInt16(entry[2 /* ButtonConfigurationTypes.BUTTON_TYPE */]);
+                let buttonName;
                 if (entry[3 /* ButtonConfigurationTypes.BUTTON_NAME */]) {
                     buttonName = entry[3 /* ButtonConfigurationTypes.BUTTON_NAME */].toString();
                 }
@@ -638,74 +631,52 @@ var RemoteController = /** @class */ (function (_super) {
             targetCategory: category,
             buttonConfiguration: buttonConfiguration,
         };
-    };
-    RemoteController.prototype.updatedTargetConfiguration = function () {
-        var e_3, _a, e_4, _b;
-        var _c;
-        var bufferList = [];
-        try {
-            for (var _d = tslib_1.__values(Object.values(this.targetConfigurations)), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var configuration = _e.value;
-                var targetIdentifier = tlv.encode(1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */, tlv.writeUInt32(configuration.targetIdentifier));
-                var targetName = tlv.encode(2 /* TargetConfigurationTypes.TARGET_NAME */, configuration.targetName);
-                var targetCategory = tlv.encode(3 /* TargetConfigurationTypes.TARGET_CATEGORY */, tlv.writeUInt16(configuration.targetCategory));
-                var buttonConfigurationBuffers = [];
-                try {
-                    for (var _f = (e_4 = void 0, tslib_1.__values(configuration.buttonConfiguration.values())), _g = _f.next(); !_g.done; _g = _f.next()) {
-                        var value = _g.value;
-                        var tlvBuffer = tlv.encode(1 /* ButtonConfigurationTypes.BUTTON_ID */, value.buttonID, 2 /* ButtonConfigurationTypes.BUTTON_TYPE */, tlv.writeUInt16(value.buttonType));
-                        if (value.buttonName) {
-                            tlvBuffer = Buffer.concat([
-                                tlvBuffer,
-                                tlv.encode(3 /* ButtonConfigurationTypes.BUTTON_NAME */, value.buttonName),
-                            ]);
-                        }
-                        buttonConfigurationBuffers.push(tlvBuffer);
-                    }
-                }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
-                    try {
-                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-                    }
-                    finally { if (e_4) throw e_4.error; }
+    }
+    updatedTargetConfiguration() {
+        const bufferList = [];
+        for (const configuration of Object.values(this.targetConfigurations)) {
+            const targetIdentifier = tlv.encode(1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */, tlv.writeUInt32(configuration.targetIdentifier));
+            const targetName = tlv.encode(2 /* TargetConfigurationTypes.TARGET_NAME */, configuration.targetName);
+            const targetCategory = tlv.encode(3 /* TargetConfigurationTypes.TARGET_CATEGORY */, tlv.writeUInt16(configuration.targetCategory));
+            const buttonConfigurationBuffers = [];
+            for (const value of configuration.buttonConfiguration.values()) {
+                let tlvBuffer = tlv.encode(1 /* ButtonConfigurationTypes.BUTTON_ID */, value.buttonID, 2 /* ButtonConfigurationTypes.BUTTON_TYPE */, tlv.writeUInt16(value.buttonType));
+                if (value.buttonName) {
+                    tlvBuffer = Buffer.concat([
+                        tlvBuffer,
+                        tlv.encode(3 /* ButtonConfigurationTypes.BUTTON_NAME */, value.buttonName),
+                    ]);
                 }
-                var buttonConfiguration = tlv.encode(4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */, Buffer.concat(buttonConfigurationBuffers));
-                var targetConfiguration = Buffer.concat([targetIdentifier, targetName, targetCategory, buttonConfiguration]);
-                bufferList.push(tlv.encode(2 /* TargetControlList.TARGET_CONFIGURATION */, targetConfiguration));
+                buttonConfigurationBuffers.push(tlvBuffer);
             }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-            }
-            finally { if (e_3) throw e_3.error; }
+            const buttonConfiguration = tlv.encode(4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */, Buffer.concat(buttonConfigurationBuffers));
+            const targetConfiguration = Buffer.concat([targetIdentifier, targetName, targetCategory, buttonConfiguration]);
+            bufferList.push(tlv.encode(2 /* TargetControlList.TARGET_CONFIGURATION */, targetConfiguration));
         }
         this.targetConfigurationsString = Buffer.concat(bufferList).toString("base64");
-        (_c = this.stateChangeDelegate) === null || _c === void 0 ? void 0 : _c.call(this);
-    };
-    RemoteController.prototype.buildTargetControlSupportedConfigurationTLV = function (configuration) {
-        var maximumTargets = tlv.encode(1 /* TargetControlCommands.MAXIMUM_TARGETS */, configuration.maximumTargets);
-        var ticksPerSecond = tlv.encode(2 /* TargetControlCommands.TICKS_PER_SECOND */, tlv.writeVariableUIntLE(configuration.ticksPerSecond));
-        var supportedButtonConfigurationBuffers = [];
-        configuration.supportedButtonConfiguration.forEach(function (value) {
-            var tlvBuffer = tlv.encode(1 /* SupportedButtonConfigurationTypes.BUTTON_ID */, value.buttonID, 2 /* SupportedButtonConfigurationTypes.BUTTON_TYPE */, tlv.writeUInt16(value.buttonType));
+        this.stateChangeDelegate?.();
+    }
+    buildTargetControlSupportedConfigurationTLV(configuration) {
+        const maximumTargets = tlv.encode(1 /* TargetControlCommands.MAXIMUM_TARGETS */, configuration.maximumTargets);
+        const ticksPerSecond = tlv.encode(2 /* TargetControlCommands.TICKS_PER_SECOND */, tlv.writeVariableUIntLE(configuration.ticksPerSecond));
+        const supportedButtonConfigurationBuffers = [];
+        configuration.supportedButtonConfiguration.forEach(value => {
+            const tlvBuffer = tlv.encode(1 /* SupportedButtonConfigurationTypes.BUTTON_ID */, value.buttonID, 2 /* SupportedButtonConfigurationTypes.BUTTON_TYPE */, tlv.writeUInt16(value.buttonType));
             supportedButtonConfigurationBuffers.push(tlvBuffer);
         });
-        var supportedButtonConfiguration = tlv.encode(3 /* TargetControlCommands.SUPPORTED_BUTTON_CONFIGURATION */, Buffer.concat(supportedButtonConfigurationBuffers));
-        var type = tlv.encode(4 /* TargetControlCommands.TYPE */, configuration.hardwareImplemented ? 1 : 0);
+        const supportedButtonConfiguration = tlv.encode(3 /* TargetControlCommands.SUPPORTED_BUTTON_CONFIGURATION */, Buffer.concat(supportedButtonConfigurationBuffers));
+        const type = tlv.encode(4 /* TargetControlCommands.TYPE */, configuration.hardwareImplemented ? 1 : 0);
         return Buffer.concat([maximumTargets, ticksPerSecond, supportedButtonConfiguration, type]).toString("base64");
-    };
+    }
     // --------------------------------- SIRI/DATA STREAM --------------------------------
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    RemoteController.prototype.handleTargetControlWhoAmI = function (connection, message) {
-        var targetIdentifier = message.identifier;
+    handleTargetControlWhoAmI(connection, message) {
+        const targetIdentifier = message.identifier;
         this.dataStreamConnections.set(targetIdentifier, connection);
         debug("Discovered HDS connection for targetIdentifier %s", targetIdentifier);
         connection.addProtocolHandler("dataSend" /* Protocols.DATA_SEND */, this);
-    };
-    RemoteController.prototype.handleSiriAudioStart = function () {
+    }
+    handleSiriAudioStart() {
         if (!this.audioSupported) {
             throw new Error("Cannot start siri stream on remote where siri is not supported");
         }
@@ -719,13 +690,13 @@ var RemoteController = /** @class */ (function (_super) {
             debug("Tried opening Siri audio stream, however there is already one in progress");
             return;
         }
-        var connection = this.dataStreamConnections.get(this.activeIdentifier); // get connection for current target
+        const connection = this.dataStreamConnections.get(this.activeIdentifier); // get connection for current target
         if (connection === undefined) { // target seems not connected, ignore it
             debug("Tried opening Siri audio stream however target is not connected via HDS");
             return;
         }
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        var audioSession = new SiriAudioSession(connection, this.selectedAudioConfiguration, this.audioProducerConstructor, this.audioProducerOptions);
+        const audioSession = new SiriAudioSession(connection, this.selectedAudioConfiguration, this.audioProducerConstructor, this.audioProducerOptions);
         if (!this.activeAudioSession) {
             this.activeAudioSession = audioSession;
         }
@@ -736,8 +707,8 @@ var RemoteController = /** @class */ (function (_super) {
         }
         audioSession.on("close" /* SiriAudioSessionEvents.CLOSE */, this.handleSiriAudioSessionClosed.bind(this, audioSession));
         audioSession.start();
-    };
-    RemoteController.prototype.handleSiriAudioStop = function () {
+    }
+    handleSiriAudioStop() {
         if (this.activeAudioSession) {
             if (!this.activeAudioSession.isClosing()) {
                 this.activeAudioSession.stop();
@@ -749,11 +720,11 @@ var RemoteController = /** @class */ (function (_super) {
             }
         }
         debug("handleSiriAudioStop called although no audio session was started");
-    };
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    RemoteController.prototype.handleDataSendAckEvent = function (message) {
-        var streamId = message.streamId;
-        var endOfStream = message.endOfStream;
+    handleDataSendAckEvent(message) {
+        const streamId = message.streamId;
+        const endOfStream = message.endOfStream;
         if (this.activeAudioSession && this.activeAudioSession.streamId === streamId) {
             this.activeAudioSession.handleDataSendAckEvent(endOfStream);
         }
@@ -763,11 +734,11 @@ var RemoteController = /** @class */ (function (_super) {
         else {
             debug("Received dataSend acknowledgment event for unknown streamId '%s'", streamId);
         }
-    };
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    RemoteController.prototype.handleDataSendCloseEvent = function (message) {
-        var streamId = message.streamId;
-        var reason = message.reason;
+    handleDataSendCloseEvent(message) {
+        const streamId = message.streamId;
+        const reason = message.reason;
         if (this.activeAudioSession && this.activeAudioSession.streamId === streamId) {
             this.activeAudioSession.handleDataSendCloseEvent(reason);
         }
@@ -777,8 +748,8 @@ var RemoteController = /** @class */ (function (_super) {
         else {
             debug("Received dataSend close event for unknown streamId '%s'", streamId);
         }
-    };
-    RemoteController.prototype.handleSiriAudioSessionClosed = function (session) {
+    }
+    handleSiriAudioSessionClosed(session) {
         if (session === this.activeAudioSession) {
             this.activeAudioSession = this.nextAudioSession;
             this.nextAudioSession = undefined;
@@ -786,38 +757,27 @@ var RemoteController = /** @class */ (function (_super) {
         else if (session === this.nextAudioSession) {
             this.nextAudioSession = undefined;
         }
-    };
-    RemoteController.prototype.handleDataStreamConnectionClosed = function (connection) {
-        var e_5, _a;
-        try {
-            for (var _b = tslib_1.__values(this.dataStreamConnections), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = tslib_1.__read(_c.value, 2), targetIdentifier = _d[0], connection0 = _d[1];
-                if (connection === connection0) {
-                    debug("HDS connection disconnected for targetIdentifier %s", targetIdentifier);
-                    this.dataStreamConnections.delete(targetIdentifier);
-                    break;
-                }
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+    }
+    handleDataStreamConnectionClosed(connection) {
+        for (const [targetIdentifier, connection0] of this.dataStreamConnections) {
+            if (connection === connection0) {
+                debug("HDS connection disconnected for targetIdentifier %s", targetIdentifier);
+                this.dataStreamConnections.delete(targetIdentifier);
+                break;
             }
-            finally { if (e_5) throw e_5.error; }
         }
-    };
+    }
     // ------------------------------- AUDIO CONFIGURATION -------------------------------
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    RemoteController.prototype.handleSelectedAudioConfigurationWrite = function (value, callback) {
-        var data = Buffer.from(value, "base64");
-        var objects = tlv.decode(data);
-        var selectedAudioStreamConfiguration = tlv.decode(objects[1 /* SelectedAudioInputStreamConfigurationTypes.SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION */]);
-        var codec = selectedAudioStreamConfiguration[1 /* AudioCodecConfigurationTypes.CODEC_TYPE */][0];
-        var parameters = tlv.decode(selectedAudioStreamConfiguration[2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */]);
-        var channels = parameters[1 /* AudioCodecParametersTypes.CHANNEL */][0];
-        var bitrate = parameters[2 /* AudioCodecParametersTypes.BIT_RATE */][0];
-        var samplerate = parameters[3 /* AudioCodecParametersTypes.SAMPLE_RATE */][0];
+    handleSelectedAudioConfigurationWrite(value, callback) {
+        const data = Buffer.from(value, "base64");
+        const objects = tlv.decode(data);
+        const selectedAudioStreamConfiguration = tlv.decode(objects[1 /* SelectedAudioInputStreamConfigurationTypes.SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION */]);
+        const codec = selectedAudioStreamConfiguration[1 /* AudioCodecConfigurationTypes.CODEC_TYPE */][0];
+        const parameters = tlv.decode(selectedAudioStreamConfiguration[2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */]);
+        const channels = parameters[1 /* AudioCodecParametersTypes.CHANNEL */][0];
+        const bitrate = parameters[2 /* AudioCodecParametersTypes.BIT_RATE */][0];
+        const samplerate = parameters[3 /* AudioCodecParametersTypes.SAMPLE_RATE */][0];
         this.selectedAudioConfiguration = {
             codecType: codec,
             parameters: {
@@ -831,20 +791,20 @@ var RemoteController = /** @class */ (function (_super) {
             audioCodecConfiguration: this.selectedAudioConfiguration,
         });
         callback();
-    };
-    RemoteController.buildSupportedAudioConfigurationTLV = function (configuration) {
-        var codecConfigurationTLV = RemoteController.buildCodecConfigurationTLV(configuration.audioCodecConfiguration);
-        var supportedAudioStreamConfiguration = tlv.encode(1 /* SupportedAudioStreamConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurationTLV);
+    }
+    static buildSupportedAudioConfigurationTLV(configuration) {
+        const codecConfigurationTLV = RemoteController.buildCodecConfigurationTLV(configuration.audioCodecConfiguration);
+        const supportedAudioStreamConfiguration = tlv.encode(1 /* SupportedAudioStreamConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurationTLV);
         return supportedAudioStreamConfiguration.toString("base64");
-    };
-    RemoteController.buildSelectedAudioConfigurationTLV = function (configuration) {
-        var codecConfigurationTLV = RemoteController.buildCodecConfigurationTLV(configuration.audioCodecConfiguration);
-        var supportedAudioStreamConfiguration = tlv.encode(1 /* SelectedAudioInputStreamConfigurationTypes.SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION */, codecConfigurationTLV);
+    }
+    static buildSelectedAudioConfigurationTLV(configuration) {
+        const codecConfigurationTLV = RemoteController.buildCodecConfigurationTLV(configuration.audioCodecConfiguration);
+        const supportedAudioStreamConfiguration = tlv.encode(1 /* SelectedAudioInputStreamConfigurationTypes.SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION */, codecConfigurationTLV);
         return supportedAudioStreamConfiguration.toString("base64");
-    };
-    RemoteController.buildCodecConfigurationTLV = function (codecConfiguration) {
-        var parameters = codecConfiguration.parameters;
-        var parametersTLV = tlv.encode(1 /* AudioCodecParametersTypes.CHANNEL */, parameters.channels, 2 /* AudioCodecParametersTypes.BIT_RATE */, parameters.bitrate, 3 /* AudioCodecParametersTypes.SAMPLE_RATE */, parameters.samplerate);
+    }
+    static buildCodecConfigurationTLV(codecConfiguration) {
+        const parameters = codecConfiguration.parameters;
+        let parametersTLV = tlv.encode(1 /* AudioCodecParametersTypes.CHANNEL */, parameters.channels, 2 /* AudioCodecParametersTypes.BIT_RATE */, parameters.bitrate, 3 /* AudioCodecParametersTypes.SAMPLE_RATE */, parameters.samplerate);
         if (parameters.rtpTime) {
             parametersTLV = Buffer.concat([
                 parametersTLV,
@@ -852,13 +812,12 @@ var RemoteController = /** @class */ (function (_super) {
             ]);
         }
         return tlv.encode(1 /* AudioCodecConfigurationTypes.CODEC_TYPE */, codecConfiguration.codecType, 2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */, parametersTLV);
-    };
+    }
     // -----------------------------------------------------------------------------------
     /**
      * @private
      */
-    RemoteController.prototype.constructServices = function () {
-        var _a;
+    constructServices() {
         this.targetControlManagementService = new Service_1.Service.TargetControlManagement("", "");
         this.targetControlManagementService.setCharacteristic(Characteristic_1.Characteristic.TargetControlSupportedConfiguration, this.supportedConfiguration);
         this.targetControlManagementService.setCharacteristic(Characteristic_1.Characteristic.TargetControlList, this.targetConfigurationsString);
@@ -884,145 +843,134 @@ var RemoteController = /** @class */ (function (_super) {
             targetControl: this.targetControlService,
             siri: this.siriService,
             audioStreamManagement: this.audioStreamManagementService,
-            dataStreamTransportManagement: (_a = this.dataStreamManagement) === null || _a === void 0 ? void 0 : _a.getService(),
+            dataStreamTransportManagement: this.dataStreamManagement?.getService(),
         };
-    };
+    }
     /**
      * @private
      */
-    RemoteController.prototype.initWithServices = function (serviceMap) {
+    initWithServices(serviceMap) {
         this.targetControlManagementService = serviceMap.targetControlManagement;
         this.targetControlService = serviceMap.targetControl;
         this.siriService = serviceMap.siri;
         this.audioStreamManagementService = serviceMap.audioStreamManagement;
         this.dataStreamManagement = new datastream_1.DataStreamManagement(serviceMap.dataStreamTransportManagement);
-    };
+    }
     /**
      * @private
      */
-    RemoteController.prototype.configureServices = function () {
-        var _a;
-        var _this = this;
+    configureServices() {
         if (!this.targetControlManagementService || !this.targetControlService) {
             throw new Error("Unexpected state: Services not configured!"); // playing it save
         }
         this.targetControlManagementService.getCharacteristic(Characteristic_1.Characteristic.TargetControlList)
-            .on("get" /* CharacteristicEventTypes.GET */, function (callback) {
-            callback(null, _this.targetConfigurationsString);
+            .on("get" /* CharacteristicEventTypes.GET */, callback => {
+            callback(null, this.targetConfigurationsString);
         })
             .on("set" /* CharacteristicEventTypes.SET */, this.handleTargetControlWrite.bind(this));
         this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ActiveIdentifier)
-            .on("get" /* CharacteristicEventTypes.GET */, function (callback) {
-            callback(undefined, _this.activeIdentifier);
+            .on("get" /* CharacteristicEventTypes.GET */, callback => {
+            callback(undefined, this.activeIdentifier);
         });
         this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.Active)
-            .on("get" /* CharacteristicEventTypes.GET */, function (callback) {
-            callback(undefined, _this.isActive());
+            .on("get" /* CharacteristicEventTypes.GET */, callback => {
+            callback(undefined, this.isActive());
         })
-            .on("set" /* CharacteristicEventTypes.SET */, function (value, callback, context, connection) {
+            .on("set" /* CharacteristicEventTypes.SET */, (value, callback, context, connection) => {
             if (!connection) {
                 debug("Set event handler for Remote.Active cannot be called from plugin. Connection undefined!");
                 callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
                 return;
             }
-            _this.handleActiveWrite(value, callback, connection);
+            this.handleActiveWrite(value, callback, connection);
         });
         this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ButtonEvent)
-            .on("get" /* CharacteristicEventTypes.GET */, function (callback) {
-            callback(undefined, _this.lastButtonEvent);
+            .on("get" /* CharacteristicEventTypes.GET */, (callback) => {
+            callback(undefined, this.lastButtonEvent);
         });
         if (this.audioSupported) {
             this.audioStreamManagementService.getCharacteristic(Characteristic_1.Characteristic.SelectedAudioStreamConfiguration)
-                .on("get" /* CharacteristicEventTypes.GET */, function (callback) {
-                callback(null, _this.selectedAudioConfigurationString);
+                .on("get" /* CharacteristicEventTypes.GET */, callback => {
+                callback(null, this.selectedAudioConfigurationString);
             })
                 .on("set" /* CharacteristicEventTypes.SET */, this.handleSelectedAudioConfigurationWrite.bind(this))
                 .updateValue(this.selectedAudioConfigurationString);
             this.dataStreamManagement
                 .onEventMessage("targetControl" /* Protocols.TARGET_CONTROL */, "whoami" /* Topics.WHOAMI */, this.handleTargetControlWhoAmI.bind(this))
                 .onServerEvent("connection-closed" /* DataStreamServerEvent.CONNECTION_CLOSED */, this.handleDataStreamConnectionClosed.bind(this));
-            this.eventHandler = (_a = {},
-                _a["ack" /* Topics.ACK */] = this.handleDataSendAckEvent.bind(this),
-                _a["close" /* Topics.CLOSE */] = this.handleDataSendCloseEvent.bind(this),
-                _a);
+            this.eventHandler = {
+                ["ack" /* Topics.ACK */]: this.handleDataSendAckEvent.bind(this),
+                ["close" /* Topics.CLOSE */]: this.handleDataSendCloseEvent.bind(this),
+            };
         }
-    };
+    }
     /**
      * @private
      */
-    RemoteController.prototype.handleControllerRemoved = function () {
-        var _a;
+    handleControllerRemoved() {
         this.targetControlManagementService = undefined;
         this.targetControlService = undefined;
         this.siriService = undefined;
         this.audioStreamManagementService = undefined;
         this.eventHandler = undefined;
         this.requestHandler = undefined;
-        (_a = this.dataStreamManagement) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.dataStreamManagement?.destroy();
         this.dataStreamManagement = undefined;
         // the call to dataStreamManagement.destroy will close any open data stream connection
         // which will result in a call to this.handleDataStreamConnectionClosed, cleaning up this.dataStreamConnections.
         // It will also result in a call to SiriAudioSession.handleDataStreamConnectionClosed (if there are any open session)
         // which again results in a call to this.handleSiriAudioSessionClosed,cleaning up this.activeAudioSession and this.nextAudioSession.
-    };
+    }
     /**
      * @private
      */
-    RemoteController.prototype.handleFactoryReset = function () {
+    handleFactoryReset() {
         debug("Running factory reset. Resetting targets...");
         this.handleResetTargets(undefined);
         this.lastButtonEvent = "";
-    };
+    }
     /**
      * @private
      */
-    RemoteController.prototype.serialize = function () {
+    serialize() {
         if (!this.activeIdentifier && Object.keys(this.targetConfigurations).length === 0) {
             return undefined;
         }
         return {
             activeIdentifier: this.activeIdentifier,
-            targetConfigurations: tslib_1.__spreadArray([], tslib_1.__read(this.targetConfigurations), false).reduce(function (obj, _a) {
-                var _b = tslib_1.__read(_a, 2), key = _b[0], value = _b[1];
+            targetConfigurations: [...this.targetConfigurations].reduce((obj, [key, value]) => {
                 obj[key] = value;
                 return obj;
             }, {}),
         };
-    };
+    }
     /**
      * @private
      */
-    RemoteController.prototype.deserialize = function (serialized) {
+    deserialize(serialized) {
         this.activeIdentifier = serialized.activeIdentifier;
-        this.targetConfigurations = Object.entries(serialized.targetConfigurations).reduce(function (map, _a) {
-            var _b = tslib_1.__read(_a, 2), key = _b[0], value = _b[1];
-            var identifier = parseInt(key, 10);
+        this.targetConfigurations = Object.entries(serialized.targetConfigurations).reduce((map, [key, value]) => {
+            const identifier = parseInt(key, 10);
             map.set(identifier, value);
             return map;
         }, new Map());
         this.updatedTargetConfiguration();
-    };
+    }
     /**
      * @private
      */
-    RemoteController.prototype.setupStateChangeDelegate = function (delegate) {
+    setupStateChangeDelegate(delegate) {
         this.stateChangeDelegate = delegate;
-    };
-    return RemoteController;
-}(events_1.EventEmitter));
+    }
+}
 exports.RemoteController = RemoteController;
 // noinspection JSUnusedGlobalSymbols
 /**
  * @deprecated - only there for backwards compatibility, please use {@link RemoteController} directly
  * @group Apple TV Remote
  */
-var HomeKitRemoteController = /** @class */ (function (_super) {
-    tslib_1.__extends(HomeKitRemoteController, _super);
-    function HomeKitRemoteController() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return HomeKitRemoteController;
-}(RemoteController)); // backwards compatibility
+class HomeKitRemoteController extends RemoteController {
+} // backwards compatibility
 exports.HomeKitRemoteController = HomeKitRemoteController;
 /**
  * @group Apple TV Remote
@@ -1036,44 +984,47 @@ var SiriAudioSessionEvents;
  * @group Apple TV Remote
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-var SiriAudioSession = /** @class */ (function (_super) {
-    tslib_1.__extends(SiriAudioSession, _super);
-    function SiriAudioSession(connection, selectedAudioConfiguration, producerConstructor, 
+class SiriAudioSession extends events_1.EventEmitter {
+    connection;
+    selectedAudioConfiguration;
+    producer;
+    producerRunning = false; // indicates if the producer is running
+    producerTimer; // producer has a 3s timeout to produce the first frame, otherwise transmission will be cancelled
+    /**
+     * @private file private API
+     */
+    state = 0 /* SiriAudioSessionState.STARTING */;
+    streamId; // present when state >= SENDING
+    endOfStream = false;
+    audioFrameQueue = [];
+    maxQueueSize = 1024;
+    sequenceNumber = 0;
+    closeListener;
+    constructor(connection, selectedAudioConfiguration, producerConstructor, 
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types,@typescript-eslint/no-explicit-any
     producerOptions) {
-        var _this = _super.call(this) || this;
-        _this.producerRunning = false; // indicates if the producer is running
-        /**
-         * @private file private API
-         */
-        _this.state = 0 /* SiriAudioSessionState.STARTING */;
-        _this.endOfStream = false;
-        _this.audioFrameQueue = [];
-        _this.maxQueueSize = 1024;
-        _this.sequenceNumber = 0;
-        _this.connection = connection;
-        _this.selectedAudioConfiguration = selectedAudioConfiguration;
-        _this.producer = new producerConstructor(_this.handleSiriAudioFrame.bind(_this), _this.handleProducerError.bind(_this), producerOptions);
-        _this.connection.on("closed" /* DataStreamConnectionEvent.CLOSED */, _this.closeListener = _this.handleDataStreamConnectionClosed.bind(_this));
-        return _this;
+        super();
+        this.connection = connection;
+        this.selectedAudioConfiguration = selectedAudioConfiguration;
+        this.producer = new producerConstructor(this.handleSiriAudioFrame.bind(this), this.handleProducerError.bind(this), producerOptions);
+        this.connection.on("closed" /* DataStreamConnectionEvent.CLOSED */, this.closeListener = this.handleDataStreamConnectionClosed.bind(this));
     }
     /**
      * Called when siri button is pressed
      */
-    SiriAudioSession.prototype.start = function () {
-        var _this = this;
+    start() {
         debug("Sending request to start siri audio stream");
         // opening dataSend
         this.connection.sendRequest("dataSend" /* Protocols.DATA_SEND */, "open" /* Topics.OPEN */, {
             target: "controller",
             type: "audio.siri",
-        }, function (error, status, message) {
-            if (_this.state === 3 /* SiriAudioSessionState.CLOSED */) {
+        }, (error, status, message) => {
+            if (this.state === 3 /* SiriAudioSessionState.CLOSED */) {
                 debug("Ignoring dataSend open response as the session is already closed");
                 return;
             }
-            assert_1.default.strictEqual(_this.state, 0 /* SiriAudioSessionState.STARTING */);
-            _this.state = 1 /* SiriAudioSessionState.SENDING */;
+            assert_1.default.strictEqual(this.state, 0 /* SiriAudioSessionState.STARTING */);
+            this.state = 1 /* SiriAudioSessionState.SENDING */;
             if (error || status) {
                 if (error) { // errors get produced by hap-nodejs
                     debug("Error occurred trying to start siri audio stream: %s", error.message);
@@ -1081,30 +1032,30 @@ var SiriAudioSession = /** @class */ (function (_super) {
                 else if (status) { // status codes are those returned by the hds response
                     debug("Controller responded with non-zero status code: %s", datastream_1.HDSStatus[status]);
                 }
-                _this.closed();
+                this.closed();
             }
             else {
-                _this.streamId = message.streamId;
-                if (!_this.producerRunning) { // audio producer errored in the meantime
-                    _this.sendDataSendCloseEvent(3 /* HDSProtocolSpecificErrorReason.CANCELLED */);
+                this.streamId = message.streamId;
+                if (!this.producerRunning) { // audio producer errored in the meantime
+                    this.sendDataSendCloseEvent(3 /* HDSProtocolSpecificErrorReason.CANCELLED */);
                 }
                 else {
-                    debug("Successfully setup siri audio stream with streamId %d", _this.streamId);
+                    debug("Successfully setup siri audio stream with streamId %d", this.streamId);
                 }
             }
         });
         this.startAudioProducer(); // start audio producer and queue frames in the meantime
-    };
+    }
     /**
      * @returns if the audio session is closing
      */
-    SiriAudioSession.prototype.isClosing = function () {
+    isClosing() {
         return this.state >= 2 /* SiriAudioSessionState.CLOSING */;
-    };
+    }
     /**
      * Called when siri button is released (or active identifier is changed to another device)
      */
-    SiriAudioSession.prototype.stop = function () {
+    stop() {
         (0, assert_1.default)(this.state <= 1 /* SiriAudioSessionState.SENDING */, "state was higher than SENDING");
         debug("Stopping siri audio stream with streamId %d", this.streamId);
         this.endOfStream = true; // mark as endOfStream
@@ -1116,28 +1067,26 @@ var SiriAudioSession = /** @class */ (function (_super) {
         else { // if state is not SENDING (aka state is STARTING) the callback for DATA_SEND OPEN did not yet return (or never will)
             this.closed();
         }
-    };
-    SiriAudioSession.prototype.startAudioProducer = function () {
-        var _this = this;
+    }
+    startAudioProducer() {
         this.producer.startAudioProduction(this.selectedAudioConfiguration);
         this.producerRunning = true;
-        this.producerTimer = setTimeout(function () {
-            debug("Didn't receive any frames from audio producer for stream with streamId %s. Canceling the stream now.", _this.streamId);
-            _this.producerTimer = undefined;
-            _this.handleProducerError(3 /* HDSProtocolSpecificErrorReason.CANCELLED */);
+        this.producerTimer = setTimeout(() => {
+            debug("Didn't receive any frames from audio producer for stream with streamId %s. Canceling the stream now.", this.streamId);
+            this.producerTimer = undefined;
+            this.handleProducerError(3 /* HDSProtocolSpecificErrorReason.CANCELLED */);
         }, 3000);
         this.producerTimer.unref();
-    };
-    SiriAudioSession.prototype.stopAudioProducer = function () {
+    }
+    stopAudioProducer() {
         this.producer.stopAudioProduction();
         this.producerRunning = false;
         if (this.producerTimer) {
             clearTimeout(this.producerTimer);
             this.producerTimer = undefined;
         }
-    };
-    SiriAudioSession.prototype.handleSiriAudioFrame = function (frame) {
-        var _this = this;
+    }
+    handleSiriAudioFrame(frame) {
         if (this.state >= 2 /* SiriAudioSessionState.CLOSING */) {
             return;
         }
@@ -1151,44 +1100,38 @@ var SiriAudioSession = /** @class */ (function (_super) {
         if (this.state !== 1 /* SiriAudioSessionState.SENDING */) { // dataSend isn't open yet
             return;
         }
-        var queued;
-        var _loop_1 = function () {
-            var packets = [];
-            queued.forEach(function (frame) {
-                var packetData = {
+        let queued;
+        while ((queued = this.popSome()) !== null) { // send packets
+            const packets = [];
+            queued.forEach(frame => {
+                const packetData = {
                     data: frame.data,
                     metadata: {
                         rms: new datastream_1.Float32(frame.rms),
-                        sequenceNumber: new datastream_1.Int64(_this.sequenceNumber++),
+                        sequenceNumber: new datastream_1.Int64(this.sequenceNumber++),
                     },
                 };
                 packets.push(packetData);
             });
-            var message = {
+            const message = {
                 packets: packets,
-                streamId: new datastream_1.Int64(this_1.streamId),
-                endOfStream: this_1.endOfStream,
+                streamId: new datastream_1.Int64(this.streamId),
+                endOfStream: this.endOfStream,
             };
             try {
-                this_1.connection.sendEvent("dataSend" /* Protocols.DATA_SEND */, "data" /* Topics.DATA */, message);
+                this.connection.sendEvent("dataSend" /* Protocols.DATA_SEND */, "data" /* Topics.DATA */, message);
             }
             catch (error) {
                 debug("Error occurred when trying to send audio frame of hds connection: %s", error.message);
-                this_1.stopAudioProducer();
-                this_1.closed();
+                this.stopAudioProducer();
+                this.closed();
             }
-            if (this_1.endOfStream) {
-                return "break";
+            if (this.endOfStream) {
+                break; // popSome() returns empty list if endOfStream=true
             }
-        };
-        var this_1 = this;
-        while ((queued = this.popSome()) !== null) {
-            var state_1 = _loop_1();
-            if (state_1 === "break")
-                break;
         }
-    };
-    SiriAudioSession.prototype.handleProducerError = function (error) {
+    }
+    handleProducerError(error) {
         if (this.state >= 2 /* SiriAudioSessionState.CLOSING */) {
             return;
         }
@@ -1196,21 +1139,21 @@ var SiriAudioSession = /** @class */ (function (_super) {
         if (this.state === 1 /* SiriAudioSessionState.SENDING */) { // if state is less than sending dataSend isn't open (yet)
             this.sendDataSendCloseEvent(error); // cancel submission
         }
-    };
-    SiriAudioSession.prototype.handleDataSendAckEvent = function (endOfStream) {
+    }
+    handleDataSendAckEvent(endOfStream) {
         assert_1.default.strictEqual(endOfStream, true);
         debug("Received acknowledgment for siri audio stream with streamId %s, closing it now", this.streamId);
         this.sendDataSendCloseEvent(0 /* HDSProtocolSpecificErrorReason.NORMAL */);
-    };
-    SiriAudioSession.prototype.handleDataSendCloseEvent = function (reason) {
+    }
+    handleDataSendCloseEvent(reason) {
         // @ts-expect-error: forceConsistentCasingInFileNames compiler option
         debug("Received close event from controller with reason %s for stream with streamId %s", datastream_1.HDSProtocolSpecificErrorReason[reason], this.streamId);
         if (this.state <= 1 /* SiriAudioSessionState.SENDING */) {
             this.stopAudioProducer();
         }
         this.closed();
-    };
-    SiriAudioSession.prototype.sendDataSendCloseEvent = function (reason) {
+    }
+    sendDataSendCloseEvent(reason) {
         (0, assert_1.default)(this.state >= 1 /* SiriAudioSessionState.SENDING */, "state was less than SENDING");
         (0, assert_1.default)(this.state <= 2 /* SiriAudioSessionState.CLOSING */, "state was higher than CLOSING");
         this.connection.sendEvent("dataSend" /* Protocols.DATA_SEND */, "close" /* Topics.CLOSE */, {
@@ -1218,36 +1161,35 @@ var SiriAudioSession = /** @class */ (function (_super) {
             reason: new datastream_1.Int64(reason),
         });
         this.closed();
-    };
-    SiriAudioSession.prototype.handleDataStreamConnectionClosed = function () {
+    }
+    handleDataStreamConnectionClosed() {
         debug("Closing audio session with streamId %d", this.streamId);
         if (this.state <= 1 /* SiriAudioSessionState.SENDING */) {
             this.stopAudioProducer();
         }
         this.closed();
-    };
-    SiriAudioSession.prototype.closed = function () {
-        var lastState = this.state;
+    }
+    closed() {
+        const lastState = this.state;
         this.state = 3 /* SiriAudioSessionState.CLOSED */;
         if (lastState !== 3 /* SiriAudioSessionState.CLOSED */) {
             this.emit("close" /* SiriAudioSessionEvents.CLOSE */);
             this.connection.removeListener("closed" /* DataStreamConnectionEvent.CLOSED */, this.closeListener);
         }
         this.removeAllListeners();
-    };
-    SiriAudioSession.prototype.popSome = function () {
+    }
+    popSome() {
         if (this.audioFrameQueue.length < 5 && !this.endOfStream) {
             return null;
         }
-        var size = Math.min(this.audioFrameQueue.length, 5); // 5 frames per hap packet seems fine
-        var result = [];
-        for (var i = 0; i < size; i++) {
-            var element = this.audioFrameQueue.shift(); // removes first element
+        const size = Math.min(this.audioFrameQueue.length, 5); // 5 frames per hap packet seems fine
+        const result = [];
+        for (let i = 0; i < size; i++) {
+            const element = this.audioFrameQueue.shift(); // removes first element
             result.push(element);
         }
         return result;
-    };
-    return SiriAudioSession;
-}(events_1.EventEmitter));
+    }
+}
 exports.SiriAudioSession = SiriAudioSession;
 //# sourceMappingURL=RemoteController.js.map