hap-nodejs 1.1.1-beta.2 → 1.1.1-beta.4

package/dist/lib/controller/RemoteController.js

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SiriAudioSession = exports.SiriAudioSessionEvents = exports.RemoteController = exports.RemoteControllerEvents = exports.TargetUpdates = exports.AudioCodecTypes = exports.ButtonState = exports.TargetCategory = exports.ButtonType = void 0;
-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");
+import assert from 'node:assert';
+import { Buffer } from 'node:buffer';
+import { EventEmitter } from 'node:events';
+import createDebug from 'debug';
+import { Characteristic } from '../Characteristic.js';
+import { DataStreamManagement, Float32, HDSStatus, Int64, } from '../datastream/index.js';
+import { Service } from '../Service.js';
+import { decode, decodeList, encode, readUInt16, readUInt32, writeUInt16, writeUInt32, writeVariableUIntLE, } from '../util/tlv.js';
+const debug = createDebug('HAP-NodeJS:Remote:Controller');
+// eslint-disable-next-line no-restricted-syntax
 var TargetControlCommands;
 (function (TargetControlCommands) {
     TargetControlCommands[TargetControlCommands["MAXIMUM_TARGETS"] = 1] = "MAXIMUM_TARGETS";
@@ -17,6 +15,7 @@ var TargetControlCommands;
     TargetControlCommands[TargetControlCommands["SUPPORTED_BUTTON_CONFIGURATION"] = 3] = "SUPPORTED_BUTTON_CONFIGURATION";
     TargetControlCommands[TargetControlCommands["TYPE"] = 4] = "TYPE";
 })(TargetControlCommands || (TargetControlCommands = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SupportedButtonConfigurationTypes;
 (function (SupportedButtonConfigurationTypes) {
     SupportedButtonConfigurationTypes[SupportedButtonConfigurationTypes["BUTTON_ID"] = 1] = "BUTTON_ID";
@@ -25,9 +24,9 @@ var SupportedButtonConfigurationTypes;
 /**
  * @group Apple TV Remote
  */
-var ButtonType;
+// eslint-disable-next-line no-restricted-syntax
+export var ButtonType;
 (function (ButtonType) {
-    // noinspection JSUnusedGlobalSymbols
     ButtonType[ButtonType["UNDEFINED"] = 0] = "UNDEFINED";
     ButtonType[ButtonType["MENU"] = 1] = "MENU";
     ButtonType[ButtonType["PLAY_PAUSE"] = 2] = "PLAY_PAUSE";
@@ -42,7 +41,8 @@ var ButtonType;
     ButtonType[ButtonType["SIRI"] = 11] = "SIRI";
     ButtonType[ButtonType["POWER"] = 12] = "POWER";
     ButtonType[ButtonType["GENERIC"] = 13] = "GENERIC";
-})(ButtonType || (exports.ButtonType = ButtonType = {}));
+})(ButtonType || (ButtonType = {}));
+// eslint-disable-next-line no-restricted-syntax
 var TargetControlList;
 (function (TargetControlList) {
     TargetControlList[TargetControlList["OPERATION"] = 1] = "OPERATION";
@@ -50,7 +50,6 @@ var TargetControlList;
 })(TargetControlList || (TargetControlList = {}));
 var Operation;
 (function (Operation) {
-    // noinspection JSUnusedGlobalSymbols
     Operation[Operation["UNDEFINED"] = 0] = "UNDEFINED";
     Operation[Operation["LIST"] = 1] = "LIST";
     Operation[Operation["ADD"] = 2] = "ADD";
@@ -58,6 +57,7 @@ var Operation;
     Operation[Operation["RESET"] = 4] = "RESET";
     Operation[Operation["UPDATE"] = 5] = "UPDATE";
 })(Operation || (Operation = {}));
+// eslint-disable-next-line no-restricted-syntax
 var TargetConfigurationTypes;
 (function (TargetConfigurationTypes) {
     TargetConfigurationTypes[TargetConfigurationTypes["TARGET_IDENTIFIER"] = 1] = "TARGET_IDENTIFIER";
@@ -68,18 +68,20 @@ var TargetConfigurationTypes;
 /**
  * @group Apple TV Remote
  */
-var TargetCategory;
+// eslint-disable-next-line no-restricted-syntax
+export var TargetCategory;
 (function (TargetCategory) {
-    // noinspection JSUnusedGlobalSymbols
     TargetCategory[TargetCategory["UNDEFINED"] = 0] = "UNDEFINED";
     TargetCategory[TargetCategory["APPLE_TV"] = 24] = "APPLE_TV";
-})(TargetCategory || (exports.TargetCategory = TargetCategory = {}));
+})(TargetCategory || (TargetCategory = {}));
+// eslint-disable-next-line no-restricted-syntax
 var ButtonConfigurationTypes;
 (function (ButtonConfigurationTypes) {
     ButtonConfigurationTypes[ButtonConfigurationTypes["BUTTON_ID"] = 1] = "BUTTON_ID";
     ButtonConfigurationTypes[ButtonConfigurationTypes["BUTTON_TYPE"] = 2] = "BUTTON_TYPE";
     ButtonConfigurationTypes[ButtonConfigurationTypes["BUTTON_NAME"] = 3] = "BUTTON_NAME";
 })(ButtonConfigurationTypes || (ButtonConfigurationTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var ButtonEvent;
 (function (ButtonEvent) {
     ButtonEvent[ButtonEvent["BUTTON_ID"] = 1] = "BUTTON_ID";
@@ -90,22 +92,25 @@ var ButtonEvent;
 /**
  * @group Apple TV Remote
  */
-var ButtonState;
+// eslint-disable-next-line no-restricted-syntax
+export var ButtonState;
 (function (ButtonState) {
     ButtonState[ButtonState["UP"] = 0] = "UP";
     ButtonState[ButtonState["DOWN"] = 1] = "DOWN";
-})(ButtonState || (exports.ButtonState = ButtonState = {}));
+})(ButtonState || (ButtonState = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SelectedAudioInputStreamConfigurationTypes;
 (function (SelectedAudioInputStreamConfigurationTypes) {
     SelectedAudioInputStreamConfigurationTypes[SelectedAudioInputStreamConfigurationTypes["SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION"] = 1] = "SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION";
 })(SelectedAudioInputStreamConfigurationTypes || (SelectedAudioInputStreamConfigurationTypes = {}));
 // ----------
+// eslint-disable-next-line no-restricted-syntax
 var SupportedAudioStreamConfigurationTypes;
 (function (SupportedAudioStreamConfigurationTypes) {
-    // noinspection JSUnusedGlobalSymbols
     SupportedAudioStreamConfigurationTypes[SupportedAudioStreamConfigurationTypes["AUDIO_CODEC_CONFIGURATION"] = 1] = "AUDIO_CODEC_CONFIGURATION";
     SupportedAudioStreamConfigurationTypes[SupportedAudioStreamConfigurationTypes["COMFORT_NOISE_SUPPORT"] = 2] = "COMFORT_NOISE_SUPPORT";
 })(SupportedAudioStreamConfigurationTypes || (SupportedAudioStreamConfigurationTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var AudioCodecConfigurationTypes;
 (function (AudioCodecConfigurationTypes) {
     AudioCodecConfigurationTypes[AudioCodecConfigurationTypes["CODEC_TYPE"] = 1] = "CODEC_TYPE";
@@ -114,9 +119,9 @@ var AudioCodecConfigurationTypes;
 /**
  * @group Camera
  */
-var AudioCodecTypes;
+// eslint-disable-next-line no-restricted-syntax
+export var AudioCodecTypes;
 (function (AudioCodecTypes) {
-    // noinspection JSUnusedGlobalSymbols
     AudioCodecTypes[AudioCodecTypes["PCMU"] = 0] = "PCMU";
     AudioCodecTypes[AudioCodecTypes["PCMA"] = 1] = "PCMA";
     AudioCodecTypes[AudioCodecTypes["AAC_ELD"] = 2] = "AAC_ELD";
@@ -124,14 +129,16 @@ var AudioCodecTypes;
     AudioCodecTypes[AudioCodecTypes["MSBC"] = 4] = "MSBC";
     AudioCodecTypes[AudioCodecTypes["AMR"] = 5] = "AMR";
     AudioCodecTypes[AudioCodecTypes["AMR_WB"] = 6] = "AMR_WB";
-})(AudioCodecTypes || (exports.AudioCodecTypes = AudioCodecTypes = {}));
+})(AudioCodecTypes || (AudioCodecTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var AudioCodecParametersTypes;
 (function (AudioCodecParametersTypes) {
     AudioCodecParametersTypes[AudioCodecParametersTypes["CHANNEL"] = 1] = "CHANNEL";
     AudioCodecParametersTypes[AudioCodecParametersTypes["BIT_RATE"] = 2] = "BIT_RATE";
     AudioCodecParametersTypes[AudioCodecParametersTypes["SAMPLE_RATE"] = 3] = "SAMPLE_RATE";
-    AudioCodecParametersTypes[AudioCodecParametersTypes["PACKET_TIME"] = 4] = "PACKET_TIME"; // only present in selected audio codec parameters tlv
+    AudioCodecParametersTypes[AudioCodecParametersTypes["PACKET_TIME"] = 4] = "PACKET_TIME";
 })(AudioCodecParametersTypes || (AudioCodecParametersTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SiriAudioSessionState;
 (function (SiriAudioSessionState) {
     SiriAudioSessionState[SiriAudioSessionState["STARTING"] = 0] = "STARTING";
@@ -142,17 +149,19 @@ var SiriAudioSessionState;
 /**
  * @group Apple TV Remote
  */
-var TargetUpdates;
+// eslint-disable-next-line no-restricted-syntax
+export var TargetUpdates;
 (function (TargetUpdates) {
     TargetUpdates[TargetUpdates["NAME"] = 0] = "NAME";
     TargetUpdates[TargetUpdates["CATEGORY"] = 1] = "CATEGORY";
     TargetUpdates[TargetUpdates["UPDATED_BUTTONS"] = 2] = "UPDATED_BUTTONS";
     TargetUpdates[TargetUpdates["REMOVED_BUTTONS"] = 3] = "REMOVED_BUTTONS";
-})(TargetUpdates || (exports.TargetUpdates = TargetUpdates = {}));
+})(TargetUpdates || (TargetUpdates = {}));
 /**
  * @group Apple TV Remote
  */
-var RemoteControllerEvents;
+// eslint-disable-next-line no-restricted-syntax
+export var RemoteControllerEvents;
 (function (RemoteControllerEvents) {
     /**
      * This event is emitted when the active state of the remote has changed.
@@ -186,18 +195,17 @@ var RemoteControllerEvents;
      * when the accessory gets unpaired.
      */
     RemoteControllerEvents["TARGETS_RESET"] = "targets-reset";
-})(RemoteControllerEvents || (exports.RemoteControllerEvents = RemoteControllerEvents = {}));
+})(RemoteControllerEvents || (RemoteControllerEvents = {}));
 /**
  * Handles everything needed to implement a fully working HomeKit remote controller.
  *
  * @group Apple TV Remote
  */
-// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-class RemoteController extends events_1.EventEmitter {
+// eslint-disable-next-line ts/no-unsafe-declaration-merging
+export class RemoteController extends EventEmitter {
     stateChangeDelegate;
     audioSupported;
     audioProducerConstructor;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     audioProducerOptions;
     targetControlManagementService;
     targetControlService;
@@ -207,8 +215,8 @@ class RemoteController extends events_1.EventEmitter {
     buttons = {}; // internal mapping of buttonId to buttonType for supported buttons
     supportedConfiguration;
     targetConfigurations = new Map();
-    targetConfigurationsString = "";
-    lastButtonEvent = "";
+    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;
@@ -235,9 +243,8 @@ class RemoteController extends events_1.EventEmitter {
      *
      * @param audioProducerConstructor - constructor for a SiriAudioStreamProducer
      * @param producerOptions - if supplied this argument will be supplied as third argument of the SiriAudioStreamProducer
-     *                          constructor. This should be used to supply configurations to the stream producer.
+     * 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
     constructor(audioProducerConstructor, producerOptions) {
         super();
         this.audioSupported = audioProducerConstructor !== undefined;
@@ -276,11 +283,11 @@ class RemoteController extends events_1.EventEmitter {
             return;
         }
         if (activeIdentifier !== 0 && !this.targetConfigurations.has(activeIdentifier)) {
-            throw Error("Tried setting unconfigured targetIdentifier to active");
+            throw new Error('Tried setting unconfigured targetIdentifier to active');
         }
-        debug("%d is now the active target", activeIdentifier);
+        debug('%d is now the active target', activeIdentifier);
         this.activeIdentifier = activeIdentifier;
-        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ActiveIdentifier).updateValue(activeIdentifier);
+        this.targetControlService.getCharacteristic(Characteristic.ActiveIdentifier).updateValue(activeIdentifier);
         if (this.activeAudioSession) {
             this.handleSiriAudioStop();
         }
@@ -310,7 +317,7 @@ class RemoteController extends events_1.EventEmitter {
     getTargetIdentifierByName(name) {
         for (const [activeIdentifier, configuration] of Object.entries(this.targetConfigurations)) {
             if (configuration.targetName === name) {
-                return parseInt(activeIdentifier, 10);
+                return Number.parseInt(activeIdentifier, 10);
             }
         }
         return undefined;
@@ -351,14 +358,23 @@ class RemoteController extends events_1.EventEmitter {
             hardwareImplemented: this.audioSupported, // siri is only allowed for hardware implemented remotes
         };
         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 */,
+            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 */,
         ];
         if (this.audioSupported) { // add siri button if this remote supports it
             supportedButtons.push(11 /* ButtonType.SIRI */);
         }
-        supportedButtons.forEach(button => {
+        supportedButtons.forEach((button) => {
             const buttonConfiguration = {
                 buttonID: 100 + button,
                 buttonType: button,
@@ -382,16 +398,15 @@ class RemoteController extends events_1.EventEmitter {
         };
     }
     // --------------------------------- TARGET CONTROL ----------------------------------
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleTargetControlWrite(value, callback) {
-        const data = Buffer.from(value, "base64");
-        const objects = tlv.decode(data);
+        const data = Buffer.from(value, 'base64');
+        const objects = decode(data);
         const operation = objects[1 /* TargetControlList.OPERATION */][0];
-        let targetConfiguration = undefined;
+        let targetConfiguration;
         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]);
+        debug('Received TargetControl write operation %s', Operation[operation]);
         let handler;
         switch (operation) {
             case Operation.ADD:
@@ -421,7 +436,7 @@ class RemoteController extends events_1.EventEmitter {
             }
         }
         else {
-            callback(new Error(status + ""));
+            callback(new Error(`${status}`));
         }
     }
     handleAddTarget(targetConfiguration) {
@@ -429,7 +444,7 @@ class RemoteController extends events_1.EventEmitter {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
         this.targetConfigurations.set(targetConfiguration.targetIdentifier, targetConfiguration);
-        debug("Configured new target '" + targetConfiguration.targetName + "' with targetIdentifier '" + targetConfiguration.targetIdentifier + "'");
+        debug(`Configured new target '${targetConfiguration.targetName}' with targetIdentifier '${targetConfiguration.targetIdentifier}'`);
         setTimeout(() => this.emit("target-add" /* RemoteControllerEvents.TARGET_ADDED */, targetConfiguration), 0);
         this.updatedTargetConfiguration(); // set response
         return 0 /* HAPStatus.SUCCESS */;
@@ -444,17 +459,17 @@ class RemoteController extends events_1.EventEmitter {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
         if (targetConfiguration.targetName) {
-            debug("Target name was updated '%s' => '%s' (%d)", configuredTarget.targetName, targetConfiguration.targetName, configuredTarget.targetIdentifier);
+            debug('Target name was updated \'%s\' => \'%s\' (%d)', configuredTarget.targetName, targetConfiguration.targetName, configuredTarget.targetIdentifier);
             configuredTarget.targetName = targetConfiguration.targetName;
             updates.push(0 /* TargetUpdates.NAME */);
         }
         if (targetConfiguration.targetCategory) {
-            debug("Target category was updated '%d' => '%d' for target '%s' (%d)", configuredTarget.targetCategory, targetConfiguration.targetCategory, configuredTarget.targetName, configuredTarget.targetIdentifier);
+            debug('Target category was updated \'%d\' => \'%d\' for target \'%s\' (%d)', configuredTarget.targetCategory, targetConfiguration.targetCategory, configuredTarget.targetName, configuredTarget.targetIdentifier);
             configuredTarget.targetCategory = targetConfiguration.targetCategory;
             updates.push(1 /* TargetUpdates.CATEGORY */);
         }
         if (targetConfiguration.buttonConfiguration) {
-            debug("%d button configurations were updated for target '%s' (%d)", Object.keys(targetConfiguration.buttonConfiguration).length, configuredTarget.targetName, configuredTarget.targetIdentifier);
+            debug('%d button configurations were updated for target \'%s\' (%d)', Object.keys(targetConfiguration.buttonConfiguration).length, configuredTarget.targetName, configuredTarget.targetIdentifier);
             for (const configuration of Object.values(targetConfiguration.buttonConfiguration)) {
                 const savedConfiguration = configuredTarget.buttonConfiguration[configuration.buttonID];
                 savedConfiguration.buttonType = configuration.buttonType;
@@ -480,15 +495,15 @@ class RemoteController extends events_1.EventEmitter {
                     delete configuredTarget.buttonConfiguration[key];
                 }
             }
-            debug("Removed %d button configurations of target '%s' (%d)", Object.keys(targetConfiguration.buttonConfiguration).length, configuredTarget.targetName, configuredTarget.targetIdentifier);
+            debug('Removed %d button configurations of target \'%s\' (%d)', Object.keys(targetConfiguration.buttonConfiguration).length, configuredTarget.targetName, configuredTarget.targetIdentifier);
             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);
+            debug('Target \'%s\' (%d) was removed', configuredTarget.targetName, configuredTarget.targetIdentifier);
             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.setActiveIdentifier(keys.length === 0 ? 0 : Number.parseInt(keys[0], 10)); // switch to next available remote
         }
         this.updatedTargetConfiguration(); // set response
         return 0 /* HAPStatus.SUCCESS */;
@@ -497,7 +512,7 @@ class RemoteController extends events_1.EventEmitter {
         if (targetConfiguration) {
             return -70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */;
         }
-        debug("Resetting all target configurations");
+        debug('Resetting all target configurations');
         this.targetConfigurations = new Map();
         this.updatedTargetConfiguration(); // set response
         setTimeout(() => this.emit("targets-reset" /* RemoteControllerEvents.TARGETS_RESET */), 0);
@@ -509,12 +524,12 @@ class RemoteController extends events_1.EventEmitter {
             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");
+        debug(`Returning ${Object.keys(this.targetConfigurations).length} target configurations`);
         return 0 /* HAPStatus.SUCCESS */;
     }
     handleActiveWrite(value, callback, connection) {
         if (this.activeIdentifier === 0) {
-            debug("Tried to change active state. There is no active target set though");
+            debug('Tried to change active state. There is no active target set though');
             callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
             return;
         }
@@ -533,7 +548,7 @@ class RemoteController extends events_1.EventEmitter {
             callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
             return;
         }
-        debug("Remote with activeTarget '%s' (%d) was set to %s", activeTarget.targetName, this.activeIdentifier, value ? "ACTIVE" : "INACTIVE");
+        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);
     }
@@ -544,27 +559,27 @@ class RemoteController extends events_1.EventEmitter {
         this.activeConnection.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.activeConnectionDisconnectListener);
         this.activeConnection = undefined;
         this.activeConnectionDisconnectListener = undefined;
-        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.Active).updateValue(false);
-        debug("Remote was set to INACTIVE");
+        this.targetControlService.getCharacteristic(Characteristic.Active).updateValue(false);
+        debug('Remote was set to INACTIVE');
         setTimeout(() => this.emit("active-change" /* RemoteControllerEvents.ACTIVE_CHANGE */, false), 0);
     }
     handleActiveSessionDisconnected(connection) {
         if (connection !== this.activeConnection) {
             return;
         }
-        debug("Active hap session disconnected!");
+        debug('Active hap session disconnected!');
         this.setInactive();
     }
     sendButtonEvent(button, buttonState) {
         const buttonID = this.buttons[button];
         if (buttonID === undefined || buttonID === 0) {
-            throw new Error("Tried sending button event for unsupported button (" + button + ")");
+            throw new Error(`Tried sending button event for unsupported button (${button})`);
         }
         if (this.activeIdentifier === 0) { // cannot press button if no device is selected
-            throw new Error("Tried sending button event although no target was selected");
+            throw new Error('Tried sending button event although no target was selected');
         }
         if (!this.isActive()) { // cannot press button if device is not active (aka no Apple TV is listening)
-            throw new Error("Tried sending button event although target was not marked as active");
+            throw new Error('Tried sending button event although target was not marked as active');
         }
         if (button === 11 /* ButtonType.SIRI */ && this.audioSupported) {
             if (buttonState === 1 /* ButtonState.DOWN */) { // start streaming session
@@ -575,32 +590,35 @@ class RemoteController extends events_1.EventEmitter {
             }
             return;
         }
-        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));
+        const buttonIdTlv = encode(1 /* ButtonEvent.BUTTON_ID */, buttonID);
+        const buttonStateTlv = encode(2 /* ButtonEvent.BUTTON_STATE */, buttonState);
+        const timestampTlv = encode(3 /* ButtonEvent.TIMESTAMP */, writeVariableUIntLE(new Date().getTime()));
+        const activeIdentifierTlv = encode(4 /* ButtonEvent.ACTIVE_IDENTIFIER */, writeUInt32(this.activeIdentifier));
         this.lastButtonEvent = Buffer.concat([
-            buttonIdTlv, buttonStateTlv, timestampTlv, activeIdentifierTlv,
-        ]).toString("base64");
-        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ButtonEvent).sendEventNotification(this.lastButtonEvent);
+            buttonIdTlv,
+            buttonStateTlv,
+            timestampTlv,
+            activeIdentifierTlv,
+        ]).toString('base64');
+        this.targetControlService.getCharacteristic(Characteristic.ButtonEvent).sendEventNotification(this.lastButtonEvent);
     }
     parseTargetConfigurationTLV(data) {
-        const configTLV = tlv.decode(data);
-        const identifier = tlv.readUInt32(configTLV[1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */]);
-        let name = undefined;
+        const configTLV = decode(data);
+        const identifier = readUInt32(configTLV[1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */]);
+        let name;
         if (configTLV[2 /* TargetConfigurationTypes.TARGET_NAME */]) {
             name = configTLV[2 /* TargetConfigurationTypes.TARGET_NAME */].toString();
         }
-        let category = undefined;
+        let category;
         if (configTLV[3 /* TargetConfigurationTypes.TARGET_CATEGORY */]) {
-            category = tlv.readUInt16(configTLV[3 /* TargetConfigurationTypes.TARGET_CATEGORY */]);
+            category = readUInt16(configTLV[3 /* TargetConfigurationTypes.TARGET_CATEGORY */]);
         }
         const buttonConfiguration = {};
         if (configTLV[4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */]) {
-            const buttonConfigurationTLV = tlv.decodeList(configTLV[4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */], 1 /* ButtonConfigurationTypes.BUTTON_ID */);
-            buttonConfigurationTLV.forEach(entry => {
+            const buttonConfigurationTLV = 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 */]);
+                const buttonType = readUInt16(entry[2 /* ButtonConfigurationTypes.BUTTON_TYPE */]);
                 let buttonName;
                 if (entry[3 /* ButtonConfigurationTypes.BUTTON_NAME */]) {
                     buttonName = entry[3 /* ButtonConfigurationTypes.BUTTON_NAME */].toString();
@@ -611,8 +629,8 @@ class RemoteController extends events_1.EventEmitter {
                 }
                 buttonConfiguration[buttonId] = {
                     buttonID: buttonId,
-                    buttonType: buttonType,
-                    buttonName: buttonName,
+                    buttonType,
+                    buttonName,
                 };
             });
         }
@@ -620,73 +638,72 @@ class RemoteController extends events_1.EventEmitter {
             targetIdentifier: identifier,
             targetName: name,
             targetCategory: category,
-            buttonConfiguration: buttonConfiguration,
+            buttonConfiguration,
         };
     }
     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 targetIdentifier = encode(1 /* TargetConfigurationTypes.TARGET_IDENTIFIER */, writeUInt32(configuration.targetIdentifier));
+            const targetName = encode(2 /* TargetConfigurationTypes.TARGET_NAME */, configuration.targetName);
+            const targetCategory = encode(3 /* TargetConfigurationTypes.TARGET_CATEGORY */, 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));
+                let tlvBuffer = encode(1 /* ButtonConfigurationTypes.BUTTON_ID */, value.buttonID, 2 /* ButtonConfigurationTypes.BUTTON_TYPE */, writeUInt16(value.buttonType));
                 if (value.buttonName) {
                     tlvBuffer = Buffer.concat([
                         tlvBuffer,
-                        tlv.encode(3 /* ButtonConfigurationTypes.BUTTON_NAME */, value.buttonName),
+                        encode(3 /* ButtonConfigurationTypes.BUTTON_NAME */, value.buttonName),
                     ]);
                 }
                 buttonConfigurationBuffers.push(tlvBuffer);
             }
-            const buttonConfiguration = tlv.encode(4 /* TargetConfigurationTypes.BUTTON_CONFIGURATION */, Buffer.concat(buttonConfigurationBuffers));
+            const buttonConfiguration = 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));
+            bufferList.push(encode(2 /* TargetControlList.TARGET_CONFIGURATION */, targetConfiguration));
         }
-        this.targetConfigurationsString = Buffer.concat(bufferList).toString("base64");
+        this.targetConfigurationsString = Buffer.concat(bufferList).toString('base64');
         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 maximumTargets = encode(1 /* TargetControlCommands.MAXIMUM_TARGETS */, configuration.maximumTargets);
+        const ticksPerSecond = encode(2 /* TargetControlCommands.TICKS_PER_SECOND */, 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));
+        configuration.supportedButtonConfiguration.forEach((value) => {
+            const tlvBuffer = encode(1 /* SupportedButtonConfigurationTypes.BUTTON_ID */, value.buttonID, 2 /* SupportedButtonConfigurationTypes.BUTTON_TYPE */, writeUInt16(value.buttonType));
             supportedButtonConfigurationBuffers.push(tlvBuffer);
         });
-        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");
+        const supportedButtonConfiguration = encode(3 /* TargetControlCommands.SUPPORTED_BUTTON_CONFIGURATION */, Buffer.concat(supportedButtonConfigurationBuffers));
+        const type = 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
     handleTargetControlWhoAmI(connection, message) {
         const targetIdentifier = message.identifier;
         this.dataStreamConnections.set(targetIdentifier, connection);
-        debug("Discovered HDS connection for targetIdentifier %s", targetIdentifier);
+        debug('Discovered HDS connection for targetIdentifier %s', targetIdentifier);
         connection.addProtocolHandler("dataSend" /* Protocols.DATA_SEND */, this);
     }
     handleSiriAudioStart() {
         if (!this.audioSupported) {
-            throw new Error("Cannot start siri stream on remote where siri is not supported");
+            throw new Error('Cannot start siri stream on remote where siri is not supported');
         }
         if (!this.isActive()) {
-            debug("Tried opening Siri audio stream, however no controller is connected!");
+            debug('Tried opening Siri audio stream, however no controller is connected!');
             return;
         }
         if (this.activeAudioSession && (!this.activeAudioSession.isClosing() || this.nextAudioSession)) {
             // there is already a session running, which is not in closing state and/or there is even already a
             // nextAudioSession running. ignoring start request
-            debug("Tried opening Siri audio stream, however there is already one in progress");
+            debug('Tried opening Siri audio stream, however there is already one in progress');
             return;
         }
         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");
+            debug('Tried opening Siri audio stream however target is not connected via HDS');
             return;
         }
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        // eslint-disable-next-line ts/no-use-before-define
         const audioSession = new SiriAudioSession(connection, this.selectedAudioConfiguration, this.audioProducerConstructor, this.audioProducerOptions);
         if (!this.activeAudioSession) {
             this.activeAudioSession = audioSession;
@@ -696,6 +713,7 @@ class RemoteController extends events_1.EventEmitter {
             // so no collision with the input device can happen
             this.nextAudioSession = audioSession;
         }
+        // eslint-disable-next-line ts/no-use-before-define
         audioSession.on("close" /* SiriAudioSessionEvents.CLOSE */, this.handleSiriAudioSessionClosed.bind(this, audioSession));
         audioSession.start();
     }
@@ -710,9 +728,8 @@ class RemoteController extends events_1.EventEmitter {
                 return;
             }
         }
-        debug("handleSiriAudioStop called although no audio session was started");
+        debug('handleSiriAudioStop called although no audio session was started');
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleDataSendAckEvent(message) {
         const streamId = message.streamId;
         const endOfStream = message.endOfStream;
@@ -723,10 +740,9 @@ class RemoteController extends events_1.EventEmitter {
             this.nextAudioSession.handleDataSendAckEvent(endOfStream);
         }
         else {
-            debug("Received dataSend acknowledgment event for unknown streamId '%s'", streamId);
+            debug('Received dataSend acknowledgment event for unknown streamId \'%s\'', streamId);
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleDataSendCloseEvent(message) {
         const streamId = message.streamId;
         const reason = message.reason;
@@ -737,7 +753,7 @@ class RemoteController extends events_1.EventEmitter {
             this.nextAudioSession.handleDataSendCloseEvent(reason);
         }
         else {
-            debug("Received dataSend close event for unknown streamId '%s'", streamId);
+            debug('Received dataSend close event for unknown streamId \'%s\'', streamId);
         }
     }
     handleSiriAudioSessionClosed(session) {
@@ -752,29 +768,28 @@ class RemoteController extends events_1.EventEmitter {
     handleDataStreamConnectionClosed(connection) {
         for (const [targetIdentifier, connection0] of this.dataStreamConnections) {
             if (connection === connection0) {
-                debug("HDS connection disconnected for targetIdentifier %s", targetIdentifier);
+                debug('HDS connection disconnected for targetIdentifier %s', targetIdentifier);
                 this.dataStreamConnections.delete(targetIdentifier);
                 break;
             }
         }
     }
     // ------------------------------- AUDIO CONFIGURATION -------------------------------
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     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 data = Buffer.from(value, 'base64');
+        const objects = decode(data);
+        const selectedAudioStreamConfiguration = 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 parameters = 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: {
-                channels: channels,
-                bitrate: bitrate,
-                samplerate: samplerate,
+                channels,
+                bitrate,
+                samplerate,
                 rtpTime: 20,
             },
         };
@@ -785,47 +800,47 @@ class RemoteController extends events_1.EventEmitter {
     }
     static buildSupportedAudioConfigurationTLV(configuration) {
         const codecConfigurationTLV = RemoteController.buildCodecConfigurationTLV(configuration.audioCodecConfiguration);
-        const supportedAudioStreamConfiguration = tlv.encode(1 /* SupportedAudioStreamConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurationTLV);
-        return supportedAudioStreamConfiguration.toString("base64");
+        const supportedAudioStreamConfiguration = encode(1 /* SupportedAudioStreamConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurationTLV);
+        return supportedAudioStreamConfiguration.toString('base64');
     }
     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");
+        const supportedAudioStreamConfiguration = encode(1 /* SelectedAudioInputStreamConfigurationTypes.SELECTED_AUDIO_INPUT_STREAM_CONFIGURATION */, codecConfigurationTLV);
+        return supportedAudioStreamConfiguration.toString('base64');
     }
     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);
+        let parametersTLV = 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,
-                tlv.encode(4 /* AudioCodecParametersTypes.PACKET_TIME */, parameters.rtpTime),
+                encode(4 /* AudioCodecParametersTypes.PACKET_TIME */, parameters.rtpTime),
             ]);
         }
-        return tlv.encode(1 /* AudioCodecConfigurationTypes.CODEC_TYPE */, codecConfiguration.codecType, 2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */, parametersTLV);
+        return encode(1 /* AudioCodecConfigurationTypes.CODEC_TYPE */, codecConfiguration.codecType, 2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */, parametersTLV);
     }
     // -----------------------------------------------------------------------------------
     /**
      * @private
      */
     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);
+        this.targetControlManagementService = new Service.TargetControlManagement('', '');
+        this.targetControlManagementService.setCharacteristic(Characteristic.TargetControlSupportedConfiguration, this.supportedConfiguration);
+        this.targetControlManagementService.setCharacteristic(Characteristic.TargetControlList, this.targetConfigurationsString);
         this.targetControlManagementService.setPrimaryService();
         // you can also expose multiple TargetControl services to control multiple apple tvs simultaneously.
         // should we extend this class to support multiple TargetControl services or should users just create a second accessory?
-        this.targetControlService = new Service_1.Service.TargetControl("", "");
-        this.targetControlService.setCharacteristic(Characteristic_1.Characteristic.ActiveIdentifier, 0);
-        this.targetControlService.setCharacteristic(Characteristic_1.Characteristic.Active, false);
-        this.targetControlService.setCharacteristic(Characteristic_1.Characteristic.ButtonEvent, this.lastButtonEvent);
+        this.targetControlService = new Service.TargetControl('', '');
+        this.targetControlService.setCharacteristic(Characteristic.ActiveIdentifier, 0);
+        this.targetControlService.setCharacteristic(Characteristic.Active, false);
+        this.targetControlService.setCharacteristic(Characteristic.ButtonEvent, this.lastButtonEvent);
         if (this.audioSupported) {
-            this.siriService = new Service_1.Service.Siri("", "");
-            this.siriService.setCharacteristic(Characteristic_1.Characteristic.SiriInputType, Characteristic_1.Characteristic.SiriInputType.PUSH_BUTTON_TRIGGERED_APPLE_TV);
-            this.audioStreamManagementService = new Service_1.Service.AudioStreamManagement("", "");
-            this.audioStreamManagementService.setCharacteristic(Characteristic_1.Characteristic.SupportedAudioStreamConfiguration, this.supportedAudioConfiguration);
-            this.audioStreamManagementService.setCharacteristic(Characteristic_1.Characteristic.SelectedAudioStreamConfiguration, this.selectedAudioConfigurationString);
-            this.dataStreamManagement = new datastream_1.DataStreamManagement();
+            this.siriService = new Service.Siri('', '');
+            this.siriService.setCharacteristic(Characteristic.SiriInputType, Characteristic.SiriInputType.PUSH_BUTTON_TRIGGERED_APPLE_TV);
+            this.audioStreamManagementService = new Service.AudioStreamManagement('', '');
+            this.audioStreamManagementService.setCharacteristic(Characteristic.SupportedAudioStreamConfiguration, this.supportedAudioConfiguration);
+            this.audioStreamManagementService.setCharacteristic(Characteristic.SelectedAudioStreamConfiguration, this.selectedAudioConfigurationString);
+            this.dataStreamManagement = new DataStreamManagement();
             this.siriService.addLinkedService(this.dataStreamManagement.getService());
             this.siriService.addLinkedService(this.audioStreamManagementService);
         }
@@ -845,43 +860,43 @@ class RemoteController extends events_1.EventEmitter {
         this.targetControlService = serviceMap.targetControl;
         this.siriService = serviceMap.siri;
         this.audioStreamManagementService = serviceMap.audioStreamManagement;
-        this.dataStreamManagement = new datastream_1.DataStreamManagement(serviceMap.dataStreamTransportManagement);
+        this.dataStreamManagement = new DataStreamManagement(serviceMap.dataStreamTransportManagement);
     }
     /**
      * @private
      */
     configureServices() {
         if (!this.targetControlManagementService || !this.targetControlService) {
-            throw new Error("Unexpected state: Services not configured!"); // playing it save
+            throw new Error('Unexpected state: Services not configured!'); // playing it save
         }
-        this.targetControlManagementService.getCharacteristic(Characteristic_1.Characteristic.TargetControlList)
-            .on("get" /* CharacteristicEventTypes.GET */, callback => {
+        this.targetControlManagementService.getCharacteristic(Characteristic.TargetControlList)
+            .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 */, callback => {
+        this.targetControlService.getCharacteristic(Characteristic.ActiveIdentifier)
+            .on("get" /* CharacteristicEventTypes.GET */, (callback) => {
             callback(undefined, this.activeIdentifier);
         });
-        this.targetControlService.getCharacteristic(Characteristic_1.Characteristic.Active)
-            .on("get" /* CharacteristicEventTypes.GET */, callback => {
+        this.targetControlService.getCharacteristic(Characteristic.Active)
+            .on("get" /* CharacteristicEventTypes.GET */, (callback) => {
             callback(undefined, this.isActive());
         })
             .on("set" /* CharacteristicEventTypes.SET */, (value, callback, context, connection) => {
             if (!connection) {
-                debug("Set event handler for Remote.Active cannot be called from plugin. Connection undefined!");
+                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.targetControlService.getCharacteristic(Characteristic_1.Characteristic.ButtonEvent)
+        this.targetControlService.getCharacteristic(Characteristic.ButtonEvent)
             .on("get" /* CharacteristicEventTypes.GET */, (callback) => {
             callback(undefined, this.lastButtonEvent);
         });
         if (this.audioSupported) {
-            this.audioStreamManagementService.getCharacteristic(Characteristic_1.Characteristic.SelectedAudioStreamConfiguration)
-                .on("get" /* CharacteristicEventTypes.GET */, callback => {
+            this.audioStreamManagementService.getCharacteristic(Characteristic.SelectedAudioStreamConfiguration)
+                .on("get" /* CharacteristicEventTypes.GET */, (callback) => {
                 callback(null, this.selectedAudioConfigurationString);
             })
                 .on("set" /* CharacteristicEventTypes.SET */, this.handleSelectedAudioConfigurationWrite.bind(this))
@@ -916,9 +931,9 @@ class RemoteController extends events_1.EventEmitter {
      * @private
      */
     handleFactoryReset() {
-        debug("Running factory reset. Resetting targets...");
+        debug('Running factory reset. Resetting targets...');
         this.handleResetTargets(undefined);
-        this.lastButtonEvent = "";
+        this.lastButtonEvent = '';
     }
     /**
      * @private
@@ -941,7 +956,7 @@ class RemoteController extends events_1.EventEmitter {
     deserialize(serialized) {
         this.activeIdentifier = serialized.activeIdentifier;
         this.targetConfigurations = Object.entries(serialized.targetConfigurations).reduce((map, [key, value]) => {
-            const identifier = parseInt(key, 10);
+            const identifier = Number.parseInt(key, 10);
             map.set(identifier, value);
             return map;
         }, new Map());
@@ -954,27 +969,27 @@ class RemoteController extends events_1.EventEmitter {
         this.stateChangeDelegate = delegate;
     }
 }
-exports.RemoteController = RemoteController;
 /**
  * @group Apple TV Remote
  */
-var SiriAudioSessionEvents;
+// eslint-disable-next-line no-restricted-syntax
+export var SiriAudioSessionEvents;
 (function (SiriAudioSessionEvents) {
     SiriAudioSessionEvents["CLOSE"] = "close";
-})(SiriAudioSessionEvents || (exports.SiriAudioSessionEvents = SiriAudioSessionEvents = {}));
+})(SiriAudioSessionEvents || (SiriAudioSessionEvents = {}));
 /**
  * Represents an ongoing audio transmission
  * @group Apple TV Remote
  */
-// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-class SiriAudioSession extends events_1.EventEmitter {
+// eslint-disable-next-line ts/no-unsafe-declaration-merging
+export class SiriAudioSession extends 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
+     * @private
      */
     state = 0 /* SiriAudioSessionState.STARTING */;
     streamId; // present when state >= SENDING
@@ -983,12 +998,11 @@ class SiriAudioSession extends events_1.EventEmitter {
     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) {
+    constructor(connection, selectedAudioConfiguration, producerConstructor, producerOptions) {
         super();
         this.connection = connection;
         this.selectedAudioConfiguration = selectedAudioConfiguration;
+        // eslint-disable-next-line new-cap
         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));
     }
@@ -996,24 +1010,24 @@ class SiriAudioSession extends events_1.EventEmitter {
      * Called when siri button is pressed
      */
     start() {
-        debug("Sending request to start siri audio stream");
+        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",
+            target: 'controller',
+            type: 'audio.siri',
         }, (error, status, message) => {
             if (this.state === 3 /* SiriAudioSessionState.CLOSED */) {
-                debug("Ignoring dataSend open response as the session is already closed");
+                debug('Ignoring dataSend open response as the session is already closed');
                 return;
             }
-            assert_1.default.strictEqual(this.state, 0 /* SiriAudioSessionState.STARTING */);
+            assert.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);
+                    debug('Error occurred trying to start siri audio stream: %s', error.message);
                 }
                 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]);
+                    debug('Controller responded with non-zero status code: %s', HDSStatus[status]);
                 }
                 this.closed();
             }
@@ -1023,7 +1037,7 @@ class SiriAudioSession extends events_1.EventEmitter {
                     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);
                 }
             }
         });
@@ -1039,8 +1053,8 @@ class SiriAudioSession extends events_1.EventEmitter {
      * Called when siri button is released (or active identifier is changed to another device)
      */
     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);
+        assert(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
         this.stopAudioProducer();
         if (this.state === 1 /* SiriAudioSessionState.SENDING */) {
@@ -1055,7 +1069,7 @@ class SiriAudioSession extends events_1.EventEmitter {
         this.producer.startAudioProduction(this.selectedAudioConfiguration);
         this.producerRunning = true;
         this.producerTimer = setTimeout(() => {
-            debug("Didn't receive any frames from audio producer for stream with streamId %s. Canceling the stream now.", this.streamId);
+            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);
@@ -1083,35 +1097,33 @@ class SiriAudioSession extends events_1.EventEmitter {
         if (this.state !== 1 /* SiriAudioSessionState.SENDING */) { // dataSend isn't open yet
             return;
         }
-        let queued;
-        while ((queued = this.popSome()) !== null) { // send packets
+        let queued = this.popSome();
+        while (queued !== null) { // send packets
             const packets = [];
-            queued.forEach(frame => {
+            queued.forEach((frame) => {
                 const packetData = {
                     data: frame.data,
                     metadata: {
-                        rms: new datastream_1.Float32(frame.rms),
-                        sequenceNumber: new datastream_1.Int64(this.sequenceNumber++),
+                        rms: new Float32(frame.rms),
+                        sequenceNumber: new Int64(this.sequenceNumber++),
                     },
                 };
                 packets.push(packetData);
             });
             const message = {
-                packets: packets,
-                streamId: new datastream_1.Int64(this.streamId),
+                packets,
+                streamId: new Int64(this.streamId),
                 endOfStream: this.endOfStream,
             };
             try {
                 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);
+                debug('Error occurred when trying to send audio frame of hds connection: %s', error.message);
                 this.stopAudioProducer();
                 this.closed();
             }
-            if (this.endOfStream) {
-                break; // popSome() returns empty list if endOfStream=true
-            }
+            queued = this.popSome();
         }
     }
     handleProducerError(error) {
@@ -1124,29 +1136,29 @@ class SiriAudioSession extends events_1.EventEmitter {
         }
     }
     handleDataSendAckEvent(endOfStream) {
-        assert_1.default.strictEqual(endOfStream, true);
-        debug("Received acknowledgment for siri audio stream with streamId %s, closing it now", this.streamId);
+        assert.strictEqual(endOfStream, true);
+        debug('Received acknowledgment for siri audio stream with streamId %s, closing it now', this.streamId);
         this.sendDataSendCloseEvent(0 /* HDSProtocolSpecificErrorReason.NORMAL */);
     }
     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);
+        debug('Received close event from controller with reason %s for stream with streamId %s', HDSProtocolSpecificErrorReason[reason], this.streamId);
         if (this.state <= 1 /* SiriAudioSessionState.SENDING */) {
             this.stopAudioProducer();
         }
         this.closed();
     }
     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");
+        assert(this.state >= 1 /* SiriAudioSessionState.SENDING */, 'state was less than SENDING');
+        assert(this.state <= 2 /* SiriAudioSessionState.CLOSING */, 'state was higher than CLOSING');
         this.connection.sendEvent("dataSend" /* Protocols.DATA_SEND */, "close" /* Topics.CLOSE */, {
-            streamId: new datastream_1.Int64(this.streamId),
-            reason: new datastream_1.Int64(reason),
+            streamId: new Int64(this.streamId),
+            reason: new Int64(reason),
         });
         this.closed();
     }
     handleDataStreamConnectionClosed() {
-        debug("Closing audio session with streamId %d", this.streamId);
+        debug('Closing audio session with streamId %d', this.streamId);
         if (this.state <= 1 /* SiriAudioSessionState.SENDING */) {
             this.stopAudioProducer();
         }
@@ -1174,5 +1186,4 @@ class SiriAudioSession extends events_1.EventEmitter {
         return result;
     }
 }
-exports.SiriAudioSession = SiriAudioSession;
 //# sourceMappingURL=RemoteController.js.map