feat(lint) update linter and apply it to TS code

.eslintignore

 # not seem to be a reason why we will want to risk being inconsistent with our
 # remaining JavaScript source code.
 !.eslintrc.js
+
+*.d.ts
+*.spec.ts
+*.spec.js

.eslintrc.js

     },
     'extends': [
         '@jitsi/eslint-config'
+    ],
+    'overrides': [
+        {
+            'files': [ '*.ts' ],
+            extends: [ '@jitsi/eslint-config/typescript' ],
+            parserOptions: {
+                sourceType: 'module',
+                project: [ 'tsconfig.json' ]
+            },
+            rules: {
+                'no-continue': 0
+            }
+        }
     ]
 };

JitsiConferenceErrors.ts

  */
 
 export enum JitsiConferenceErrors {
+
     /**
      * Indicates that client must be authenticated to create the conference.
      */
     CHAT_ERROR = 'conference.chatError',
 
     /**
-     * Indicates that a settings error occurred.
+     * Indicates that a connection error is due to denied access to the room,
+     * occurred after joining a lobby room and access is denied by the room moderators.
      */
-    SETTINGS_ERROR = 'conference.settingsError',
+    CONFERENCE_ACCESS_DENIED = 'conference.connectionError.accessDenied',
 
     /**
      * Indicates that conference has been destroyed.
      */
     CONFERENCE_MAX_USERS = 'conference.max_users',
 
-    /**
-     * Indicates that a connection error occurred when trying to join a conference.
-     */
-    CONNECTION_ERROR = 'conference.connectionError',
-
     /**
      * Indicates that the client has been forced to restart by jicofo when the
      * conference was migrated from one bridge to another.
     CONFERENCE_RESTARTED = 'conference.restarted',
 
     /**
-     * Indicates that a connection error is due to not allowed,
-     * occurred when trying to join a conference.
-     */
-    NOT_ALLOWED_ERROR = 'conference.connectionError.notAllowed',
-
-    /**
-     * Indicates that a connection error is due to not allowed,
-     * occurred when trying to join a conference, only approved members are allowed to join.
-     */
-    MEMBERS_ONLY_ERROR = 'conference.connectionError.membersOnly',
-
-    /**
-     * Indicates that a connection error is due to denied access to the room,
-     * occurred after joining a lobby room and access is denied by the room moderators.
+     * Indicates that a connection error occurred when trying to join a conference.
      */
-    CONFERENCE_ACCESS_DENIED = 'conference.connectionError.accessDenied',
+    CONNECTION_ERROR = 'conference.connectionError',
 
     /**
      * Indicates that the display name is required when joining the room.
      */
     INCOMPATIBLE_SERVER_VERSIONS = 'conference.incompatible_server_versions',
 
+    /**
+     * Indicates that a connection error is due to not allowed,
+     * occurred when trying to join a conference, only approved members are allowed to join.
+     */
+    MEMBERS_ONLY_ERROR = 'conference.connectionError.membersOnly',
+
+    /**
+     * Indicates that a connection error is due to not allowed,
+     * occurred when trying to join a conference.
+     */
+    NOT_ALLOWED_ERROR = 'conference.connectionError.notAllowed',
+
     /**
      * Indicates that offer/answer had failed.
      */
      */
     RESERVATION_ERROR = 'conference.reservationError',
 
+    /**
+     * Indicates that a settings error occurred.
+     */
+    SETTINGS_ERROR = 'conference.settingsError',
+
     /**
      * Indicates that there is no available videobridge.
      */

JitsiConferenceEvents.ts

  * The events for the conference.
  */
 export enum JitsiConferenceEvents {
-    /**
-     * An event(library-private) fired when the conference switches the currently active media session.
-     * @type {string}
-     * @private
-     */
-    _MEDIA_SESSION_ACTIVE_CHANGED = 'conference.media_session.active_changed',
-
-    /**
-     * An event(library-private) fired when a new media session is added to the conference.
-     * @type {string}
-     * @private
-     */
-    _MEDIA_SESSION_STARTED = 'conference.media_session.started',
 
     /**
      * Event indicates that the current conference audio input switched between audio
     AUDIO_INPUT_STATE_CHANGE = 'conference.audio_input_state_changed',
 
     /**
-     * Event indicates that the permission for unmuting audio has changed based on the number of audio senders in the call
-     * and the audio sender limit configured in Jicofo.
+     * Event indicates that the permission for unmuting audio has changed based on the number of audio senders in the
+     * call and the audio sender limit configured in Jicofo.
      */
     AUDIO_UNMUTE_PERMISSIONS_CHANGED = 'conference.audio_unmute_permissions_changed',
 
      */
     CONFERENCE_FAILED = 'conference.failed',
 
-    /**
-     * Indicates that conference is in progress of joining.
-     */
-    CONFERENCE_JOIN_IN_PROGRESS = 'conference.join_in_progress',
-
     /**
      * Indicates that conference has been joined. The event does NOT provide any
      * parameters to its listeners.
      */
     CONFERENCE_JOINED = 'conference.joined',
 
+    /**
+     * Indicates that conference is in progress of joining.
+     */
+    CONFERENCE_JOIN_IN_PROGRESS = 'conference.join_in_progress',
+
     /**
      * Indicates that conference has been left.
      */
 
     /**
      * A connection to the video bridge's data channel has been closed.
-     * This event is only emitted in 
+     * This event is only emitted in
      */
     DATA_CHANNEL_CLOSED = 'conference.dataChannelClosed',
 
      */
     MESSAGE_RECEIVED = 'conference.messageReceived',
 
-    /**
-     * New reaction was received.
-     */
-    REACTION_RECEIVED = 'conference.reactionReceived',
-
     /**
      * Event fired when the conference metadata is updated.
      */
     METADATA_UPDATED = 'conference.metadata.updated',
 
-    /**
-     * Event indicates that the current selected input device has no signal
-     */
-    NO_AUDIO_INPUT = 'conference.no_audio_input',
-
     /**
      * Event indicates that the current microphone used by the conference is noisy.
      */
      */
     NON_PARTICIPANT_MESSAGE_RECEIVED = 'conference.non_participant_message_received',
 
+    /**
+     * Event indicates that the current selected input device has no signal
+     */
+    NO_AUDIO_INPUT = 'conference.no_audio_input',
+
     /**
      * Indicates that the conference has switched between JVB and P2P connections.
      * The first argument of this event is a <tt>boolean</tt> which when set to
      * New private text message was received.
      */
     PRIVATE_MESSAGE_RECEIVED = 'conference.privateMessageReceived',
+
     /**
      * The conference properties changed.
      * @type {string}
      */
     PROPERTIES_CHANGED = 'conference.propertiesChanged',
 
+    /**
+     * New reaction was received.
+     */
+    REACTION_RECEIVED = 'conference.reactionReceived',
+
     /**
      * Indicates that recording state changed.
      */
     SILENT_STATUS_CHANGED = 'conference.silentStatusChanged',
 
     /**
-     * Indicates that start muted settings changed.
+     * Indicates that the local user has started muted.
      */
-    START_MUTED_POLICY_CHANGED = 'conference.start_muted_policy_changed',
+    STARTED_MUTED = 'conference.started_muted',
 
     /**
-     * Indicates that the local user has started muted.
+     * Indicates that start muted settings changed.
      */
-    STARTED_MUTED = 'conference.started_muted',
+    START_MUTED_POLICY_CHANGED = 'conference.start_muted_policy_changed',
 
     /**
      * Indicates that subject of the conference has changed.
     VIDEO_SIP_GW_SESSION_STATE_CHANGED = 'conference.videoSIPGWSessionStateChanged',
 
     /**
-     * Event indicates that the permission for unmuting video has changed based on the number of video senders in the call
-     * and the video sender limit configured in Jicofo.
+     * Event indicates that the permission for unmuting video has changed based on the number of video senders in the
+     * call and the video sender limit configured in Jicofo.
      */
     VIDEO_UNMUTE_PERMISSIONS_CHANGED = 'conference.video_unmute_permissions_changed',
 
+    /**
+     * Event indicating we have received a message from the visitors component.
+     */
+    VISITORS_MESSAGE = 'conference.visitors_message',
+
+    /**
+     * Event indicating that our request for promotion was rejected.
+     */
+    VISITORS_REJECTION = 'conference.visitors_rejection',
+
     /**
      * Indicates that the conference has support for visitors.
      */
     VISITORS_SUPPORTED_CHANGED = 'conference.visitorsSupported',
 
     /**
-     * Event indicating we have received a message from the visitors component.
+     * An event(library-private) fired when the conference switches the currently active media session.
+     * @type {string}
+     * @private
      */
-    VISITORS_MESSAGE = 'conference.visitors_message',
+    _MEDIA_SESSION_ACTIVE_CHANGED = 'conference.media_session.active_changed',
 
     /**
-     * Event indicating that our request for promotion was rejected.
+     * An event(library-private) fired when a new media session is added to the conference.
+     * @type {string}
+     * @private
      */
-    VISITORS_REJECTION = 'conference.visitors_rejection'
+    _MEDIA_SESSION_STARTED = 'conference.media_session.started'
 }
 
 // exported for backward compatibility

JitsiConnectionErrors.ts

  */
 
 export enum JitsiConnectionErrors {
+
     /**
      * When the conference-request to jicofo fails.
      */
-    CONFERENCE_REQUEST_FAILED = "connection.conferenceRequestFailed",
+    CONFERENCE_REQUEST_FAILED = 'connection.conferenceRequestFailed',
 
     /**
      * Indicates that the connection was dropped with an error which was most likely
      * errors on BOSH requests.
      */
     SERVER_ERROR = 'connection.serverError'
-};
+}
 
 // exported for backward compatibility
 export const CONFERENCE_REQUEST_FAILED = JitsiConnectionErrors.CONFERENCE_REQUEST_FAILED;

JitsiConnectionEvents.ts

  */
 
 export enum JitsiConnectionEvents {
+
     /**
      * Indicates that the connection has been disconnected. The event provides
      * the following parameters to its listeners:
      */
     CONNECTION_REDIRECTED = 'connection.redirected',
 
-    /**
-     * Indicates that the performed action cannot be executed because the
-     * connection is not in the correct state(connected, disconnected, etc.)
-     */
-    WRONG_STATE = 'connection.wrongState',
-
     /**
      * Indicates that the display name is required over this connection and need to be supplied when
      * joining the room.
      * Indicates that the connection properties have been updated.
      * @param properties {object} - All available connection properties (e.g. shard, region).
      */
-    PROPERTIES_UPDATED = 'connection.propertiesUpdated'
+    PROPERTIES_UPDATED = 'connection.propertiesUpdated',
+
+    /**
+     * Indicates that the performed action cannot be executed because the
+     * connection is not in the correct state(connected, disconnected, etc.)
+     */
+    WRONG_STATE = 'connection.wrongState'
 }
 
 // exported for backward compatibility

JitsiMediaDevicesEvents.ts

  */
 
 export enum JitsiMediaDevicesEvents {
+
     /**
      * Indicates that the list of available media devices has been changed. The
      * event provides the following parameters to its listeners:
      *  other execution environment.
      */
     PERMISSION_PROMPT_IS_SHOWN = 'mediaDevices.permissionPromptIsShown'
-};
+}
 
 // exported for backward compatibility
 export const DEVICE_LIST_CHANGED = JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED;

JitsiMeetJS.ts

 import * as JitsiTranscriptionStatus from './JitsiTranscriptionStatus';
 import RTC from './modules/RTC/RTC';
 import RTCStats from './modules/RTCStats/RTCStats';
+import * as RTCStatsEvents from './modules/RTCStats/RTCStatsEvents';
 import browser from './modules/browser';
 import NetworkInfo from './modules/connectivity/NetworkInfo';
 import { TrackStreamingStatus } from './modules/connectivity/TrackStreamingStatus';
 import recordingConstants from './modules/recording/recordingConstants';
 import Settings from './modules/settings/Settings';
 import LocalStatsCollector from './modules/statistics/LocalStatsCollector';
+import runPreCallTest, { IIceServer, IPreCallResult } from './modules/statistics/PreCallTest';
 import Statistics from './modules/statistics/statistics';
 import ScriptUtil from './modules/util/ScriptUtil';
 import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
 import AudioMixer from './modules/webaudio/AudioMixer';
 import { MediaType } from './service/RTC/MediaType';
+import { VideoType } from './service/RTC/VideoType';
 import * as ConnectionQualityEvents
     from './service/connectivity/ConnectionQualityEvents';
 import * as E2ePingEvents from './service/e2eping/E2ePingEvents';
 import { createGetUserMediaEvent } from './service/statistics/AnalyticsEvents';
-import *  as RTCStatsEvents from './modules/RTCStats/RTCStatsEvents';
-import { VideoType } from './service/RTC/VideoType';
-import runPreCallTest, { IceServer, PreCallResult } from './modules/statistics/PreCallTest';
 
 const logger = Logger.getLogger(__filename);
 
 function getAnalyticsAttributesFromOptions(options) {
     const attributes: any = {};
 
-    attributes['audio_requested'] = options.devices.includes('audio');
-    attributes['video_requested'] = options.devices.includes('video');
-    attributes['screen_sharing_requested'] = options.devices.includes('desktop');
+    /* eslint-disable */
+
+    attributes.audio_requested = options.devices.includes(MediaType.AUDIO);
+    attributes.video_requested = options.devices.includes(MediaType.VIDEO);
+    attributes.screen_sharing_requested = options.devices.includes(VideoType.DESKTOP);
 
     if (attributes.video_requested) {
         attributes.resolution = options.resolution;
     }
 
+    /* eslint-enable */
+
     return attributes;
 }
 
     flags?: {
         runInLiteMode?: boolean;
         ssrcRewritingEnabled?: boolean;
-    }
+    };
 }
 
 interface ICreateLocalTrackFromMediaStreamOptions {
-    stream: MediaStream,
-    sourceType: string,
-    mediaType: MediaType,
-    videoType?: VideoType
+    mediaType: MediaType;
+    sourceType: string;
+    stream: MediaStream;
+    track: any;
+    videoType?: VideoType;
 }
 
 /**
      */
     createLocalTracks(options: ICreateLocalTrackOptions = {}) {
         let isFirstGUM = false;
-        let startTS = window.performance.now();
+        const startTS = window.performance.now();
 
         if (!window.connectionTimes) {
             window.connectionTimes = {};
 
         return RTC.obtainAudioAndVideoPermissions(options)
             .then(tracks => {
-                let endTS = window.performance.now();
+                const endTS = window.performance.now();
 
                 window.connectionTimes['obtainPermissions.end'] = endTS;
 
                         createGetUserMediaEvent('error', attributes));
                 }
 
-                let endTS = window.performance.now();
+                const endTS = window.performance.now();
 
                 window.connectionTimes['obtainPermissions.end'] = endTS;
 
      * @param {Array<ICreateLocalTrackFromMediaStreamOptions>} tracksInfo - array of track information
      * @returns {Array<JitsiLocalTrack>} - created local tracks
      */
-    createLocalTracksFromMediaStreams(tracksInfo) {
-        return RTC.createLocalTracks(tracksInfo.map((trackInfo) => {
+    createLocalTracksFromMediaStreams(tracksInfo: ICreateLocalTrackFromMediaStreamOptions[]) {
+        return RTC.createLocalTracks(tracksInfo.map(trackInfo => {
             const tracks = trackInfo.stream.getTracks()
                 .filter(track => track.kind === trackInfo.mediaType);
 
             if (!tracks || tracks.length === 0) {
+                // eslint-disable-next-line @typescript-eslint/only-throw-error
                 throw new JitsiTrackError(JitsiTrackErrors.TRACK_NO_STREAM_TRACKS_FOUND, null, null);
             }
 
             if (tracks.length > 1) {
+                // eslint-disable-next-line @typescript-eslint/only-throw-error
                 throw new JitsiTrackError(JitsiTrackErrors.TRACK_TOO_MANY_TRACKS_IN_STREAM, null, null);
             }
 
     /**
      * Run a pre-call test to check the network conditions.
      *
-     * @param {IceServer} iceServers  - The ICE servers to use for the test,
-     * @returns {Promise<PreCallResult | any>} - A Promise that resolves with the test results or rejects with an error message.
+     * @param {IIceServer} iceServers  - The ICE servers to use for the test,
+     * @returns {Promise<PreCallResult | any>} - A Promise that resolves with the test results or rejects with an error
+     * message.
      */
-    runPreCallTest(iceServers) {
+    runPreCallTest(iceServers: IIceServer[]): Promise<IPreCallResult | any> {
         return runPreCallTest(iceServers);
     },
 

JitsiTrackErrors.ts

  */
 
 export enum JitsiTrackErrors {
+
     /**
      * An error which indicates that some of requested constraints in
      * getUserMedia call were not satisfied.
     TRACK_NO_STREAM_FOUND = 'track.no_stream_found',
 
     /**
-     * An error which indicates that requested video resolution is not supported
-     * by a webcam.
+     * An error which indicates that no tracks were found in the media stream
      */
-    UNSUPPORTED_RESOLUTION = 'gum.unsupported_resolution',
+    TRACK_NO_STREAM_TRACKS_FOUND = 'track.no_stream_tracks_found',
 
     /**
      * An error which indicates that there are too many tracks in the provided media stream
     TRACK_TOO_MANY_TRACKS_IN_STREAM = 'track.too_many_tracks_in_stream',
 
     /**
-     * An error which indicates that no tracks were found in the media stream
+     * An error which indicates that requested video resolution is not supported
+     * by a webcam.
      */
-    TRACK_NO_STREAM_TRACKS_FOUND = 'track.no_stream_tracks_found',
+    UNSUPPORTED_RESOLUTION = 'gum.unsupported_resolution'
 }
 
 // exported for backward compatibility

JitsiTrackEvents.ts

 export enum JitsiTrackEvents {
+
     /**
      * The media track was removed to the conference.
      */
     LOCAL_TRACK_STOPPED = 'track.stopped',
 
+    /**
+     * Indicates that the local audio track is not receiving any audio input from
+     * the microphone that is currently selected.
+     */
+    NO_AUDIO_INPUT = 'track.no_audio_input',
+
+    /**
+     * Indicates that the track is not receiving any data even though we expect it
+     * to receive data (i.e. the stream is not stopped).
+     */
+    NO_DATA_FROM_SOURCE = 'track.no_data_from_source',
+
     /**
      * Audio levels of a this track was changed.
      * The first argument is a number with audio level value in range [0, 1].
      */
     TRACK_MUTE_CHANGED = 'track.trackMuteChanged',
 
-    /**
-     * The video type("camera" or "desktop") of the track was changed.
-     */
-    TRACK_VIDEOTYPE_CHANGED = 'track.videoTypeChanged',
-
-    /**
-     * Indicates that the track is not receiving any data even though we expect it
-     * to receive data (i.e. the stream is not stopped).
-     */
-    NO_DATA_FROM_SOURCE = 'track.no_data_from_source',
-
-    /**
-     * Indicates that the local audio track is not receiving any audio input from
-     * the microphone that is currently selected.
-     */
-    NO_AUDIO_INPUT = 'track.no_audio_input',
-
     /**
      * Indicates that a new owner has been assigned to a remote track when SSRC rewriting is enabled.
      */
 
     /**
      * Event fired whenever video track's streaming changes.
-     * First argument is the sourceName of the track and the second is a string indicating if the connection is currently
+     * First argument is the sourceName of the track and the second is a string indicating if the connection is
+     * currently
      * - active - the connection is active.
-     * - inactive - the connection is inactive, was intentionally interrupted by the bridge because of low BWE or because
-     *   of the endpoint falling out of last N.
+     * - inactive - the connection is inactive, was intentionally interrupted by the bridge because of low BWE or
+     *   because of the endpoint falling out of last N.
      * - interrupted - a network problem occurred.
      * - restoring - the connection was inactive and is restoring now.
      *
      * The current status value can be obtained by calling JitsiRemoteTrack.getTrackStreamingStatus().
      */
     TRACK_STREAMING_STATUS_CHANGED = 'track.streaming_status_changed',
-};
+
+    /**
+     * The video type("camera" or "desktop") of the track was changed.
+     */
+    TRACK_VIDEOTYPE_CHANGED = 'track.videoTypeChanged'
+}
 
 // exported for backward compatibility
 export const LOCAL_TRACK_STOPPED = JitsiTrackEvents.LOCAL_TRACK_STOPPED;

JitsiTranscriptionStatus.ts

 export enum JitsiTranscriptionStatus {
+
     /**
-     * The transcription is on.
+     * The transcription is off.
      */
-    ON = 'ON',
+    OFF = 'OFF',
 
     /**
-     * The transcription is off.
+     * The transcription is on.
      */
-    OFF = 'OFF'
+    ON = 'ON'
 }
 
 // exported for backward compatibility

index.js

 function _mergeNamespaceAndModule(module) {
     return (
         typeof window.JitsiMeetJS === 'object'
-            ? Object.assign({}, window.JitsiMeetJS, module)
+            ? { ...window.JitsiMeetJS,
+                ...module }
             : module);
 }
 

modules/RTC/JitsiLocalTrack.js

             };
 
             promise
-                = RTCUtils.obtainAudioAndVideoPermissions(Object.assign(
-                    {},
-                    streamOptions,
-                    { constraints: { video: this._constraints } }));
+                = RTCUtils.obtainAudioAndVideoPermissions({
+
+                    ...streamOptions,
+                    constraints: { video: this._constraints } });
 
             promise = promise.then(streamsInfo => {
                 const streamInfo = streamsInfo.find(info => info.track.kind === this.getType());

modules/RTCStats/DefaulLogStorage.ts

 export default class DefaultLogStorage {
     private rtcStats: any;
 
+    /**
+     * Creates new instance of <tt>DefaultLogStorage</tt>.
+     * @param rtcStats - The RTCStats instance.
+     */
     constructor(rtcStats: any) {
         this.rtcStats = rtcStats;
     }
+
+
     /**
      * The DefaultLogStorage is ready when the RTCStats is ready.
      *

modules/RTCStats/RTCStats.ts

 import Logger, { getLogger } from '@jitsi/logger';
-
 import rtcstatsInit from '@jitsi/rtcstats/rtcstats';
 import traceInit from '@jitsi/rtcstats/trace-ws';
 
+import JitsiConference from '../../JitsiConference';
 import {
     BEFORE_STATISTICS_DISPOSED,
     CONFERENCE_CREATED_TIMESTAMP,
     CONFERENCE_LEFT,
     CONFERENCE_UNIQUE_ID_SET
 } from '../../JitsiConferenceEvents';
-import JitsiConference from '../../JitsiConference';
-import { IRTCStatsConfiguration } from './interfaces';
-import { RTC_STATS_PC_EVENT, RTC_STATS_WC_DISCONNECTED } from './RTCStatsEvents';
-import EventEmitter from '../util/EventEmitter';
 import Settings from '../settings/Settings';
+import EventEmitter from '../util/EventEmitter';
+
 import DefaultLogStorage from './DefaulLogStorage';
+import { RTC_STATS_PC_EVENT, RTC_STATS_WC_DISCONNECTED } from './RTCStatsEvents';
+import { IRTCStatsConfiguration } from './interfaces';
 
 const logger = getLogger(__filename);
 
 /**
- * RTCStats Singleton that is initialized only once for the lifetime of the app, subsequent calls to init will be ignored.
- * Config and conference changes are handled by the start method.
+ * RTCStats Singleton that is initialized only once for the lifetime of the app, subsequent calls to init will be
+ * ignored. Config and conference changes are handled by the start method.
  */
 class RTCStats {
     private _initialized: boolean = false;
         const {
             analytics: {
                 rtcstatsUseLegacy: useLegacy = false,
-                rtcstatsPollInterval: pollInterval= 10000,
+                rtcstatsPollInterval: pollInterval = 10000,
                 rtcstatsSendSdp: sendSdp = false,
                 rtcstatsEnabled = false
             } = {}
         // If rtcstats is not enabled or already initialized, do nothing.
         // Calling rtcsatsInit multiple times will cause the global objects to be rewritten multiple times,
         // with unforeseen consequences.
-        if (!rtcstatsEnabled || this._initialized) return;
+        if (!rtcstatsEnabled || this._initialized) {
+            return;
+        }
 
         rtcstatsInit(
             { statsEntry: this.sendStatsEntry.bind(this) },
             { pollInterval,
-              useLegacy,
-              sendSdp,
-              eventCallback: (event) => this.events.emit(RTC_STATS_PC_EVENT, event)}
+                useLegacy,
+                sendSdp,
+                eventCallback: event => this.events.emit(RTC_STATS_PC_EVENT, event) }
         );
 
         this._initialized = true;
     start(conference: JitsiConference) {
         const {
             options: {
-                config : confConfig = {},
+                config: confConfig = {},
                 name: confName = ''
             } = {},
-            _statsCurrentId : displayName = ''
+            _statsCurrentId: displayName = ''
         } = conference;
 
         const {
         this.reset();
 
         // The new conference config might have rtcstats disabled, so we need to check again.
-        if (!rtcstatsEnabled) return;
+        if (!rtcstatsEnabled) {
+            return;
+        }
 
         // If rtcstats proxy module is not initialized, do nothing.
         if (!this._initialized) {
             const traceOptions = {
                 endpoint,
                 meetingFqn: confName,
-                onCloseCallback: (event) => this.events.emit(RTC_STATS_WC_DISCONNECTED, event),
+                onCloseCallback: event => this.events.emit(RTC_STATS_WC_DISCONNECTED, event),
                 useLegacy
             };
 
                 meetingUniqueId,
                 isBreakoutRoom,
                 localId
-            }
+            };
 
             this.sendIdentity(identityData);
         });
 
         // Note, this will only be called for normal rooms, not breakout rooms.
-        conference.once(CONFERENCE_UNIQUE_ID_SET, (meetingUniqueId) => {
-            this.sendIdentity({meetingUniqueId});
+        conference.once(CONFERENCE_UNIQUE_ID_SET, meetingUniqueId => {
+            this.sendIdentity({ meetingUniqueId });
         });
 
         conference.once(CONFERENCE_LEFT, () => {
 
         conference.once(CONFERENCE_CREATED_TIMESTAMP, (timestamp: number) => {
             this.sendStatsEntry('conferenceStartTimestamp', null, timestamp);
-        })
+        });
 
         conference.once(
             BEFORE_STATISTICS_DISPOSED,

modules/RTCStats/RTCStatsEvents.ts

  * Events emitted by the RTCStats module.
  */
 export enum RTCStatsEvents {
-    /**
-     * Event emitted when the websocket connection to the rtcstats server is disconnected.
-     */
-    RTC_STATS_WC_DISCONNECTED = 'rtcstats_ws_disconnected',
 
     /**
      * Event emitted when any PeerConnection event is triggered.
-     * 
+     *
      * @param {object} event - The PeerConnection event.
      * @param {string} event.type - The event type.
      * @param {object} event.body - Event body.
      * @param {string} event.body.state - PeerConnection state change which triggered the event.
      */
     RTC_STATS_PC_EVENT = 'rtstats_pc_event',
-};
+
+    /**
+     * Event emitted when the websocket connection to the rtcstats server is disconnected.
+     */
+    RTC_STATS_WC_DISCONNECTED = 'rtcstats_ws_disconnected'
+}
 
 // exported for backward compatibility
 export const RTC_STATS_WC_DISCONNECTED = RTCStatsEvents.RTC_STATS_WC_DISCONNECTED;

modules/connectivity/IceFailedHandling.ts

 import { getLogger } from '@jitsi/logger';
 
+import JitsiConference from '../../JitsiConference';
 import * as JitsiConferenceErrors from '../../JitsiConferenceErrors';
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
-import JitsiConference from '../../JitsiConference';
 
 const logger = getLogger(__filename);
 
      * Creates new {@code DelayedIceFailed} task.
      * @param {JitsiConference} conference
      */
-    constructor(conference:JitsiConference) {
+    constructor(conference: JitsiConference) {
         this._conference = conference;
     }
 
         }
 
         const jvbConnection = this._conference.jvbJingleSession;
-        const jvbConnIceState = jvbConnection && jvbConnection.getIceConnectionState();
+        const jvbConnIceState = jvbConnection?.getIceConnectionState();
 
         if (!jvbConnection) {
             logger.warn('Not sending ICE failed - no JVB connection');

modules/connectivity/TrackStreamingStatus.ts

 import { JitsiConferenceEvents } from '../../JitsiConferenceEvents';
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 import RTCEvents from '../../service/RTC/RTCEvents';
+import { VideoType } from '../../service/RTC/VideoType';
 import { createTrackStreamingStatusEvent } from '../../service/statistics/AnalyticsEvents';
-import browser from '../browser';
-import Statistics from '../statistics/statistics';
 import JitsiRemoteTrack from '../RTC/JitsiRemoteTrack';
-import { VideoType } from '../../service/RTC/VideoType';
 import RTC from '../RTC/RTC';
+import browser from '../browser';
+import Statistics from '../statistics/statistics';
 
 /** Track streaming statuses. */
 export enum TrackStreamingStatus {
      * Status indicating that streaming is currently restoring.
      */
     RESTORING = 'restoring',
-  }
+}
 
 type StreamingStatusMap = {
-    videoType?: VideoType,
-    startedMs?: number,
-    p2p?: boolean,
-    streamingStatus?: string,
-    value?: number
+    p2p?: boolean;
+    startedMs?: number;
+    streamingStatus?: string;
+    value?: number;
+    videoType?: VideoType;
 };
 
 const logger = getLogger(__filename);
     _onLastNValueChanged: () => void;
     _onForwardedSourcesChanged: () => void;
 
-    /* eslint-disable max-params*/
+    /* eslint-disable max-params */
     /**
      * Calculates the new {@link TrackStreamingStatus} based on the values given for some specific remote track. It is
      * assumed that the conference is currently in the JVB mode (in contrary to the P2P mode)
         return isInForwardedSources ? TrackStreamingStatus.ACTIVE : TrackStreamingStatus.INACTIVE;
     }
 
-    /* eslint-enable max-params*/
+    /* eslint-enable max-params */
 
     /**
      * In P2P mode we don't care about any values coming from the JVB and the streaming status can be only active or
      * {@link TrackStreamingStatusImpl.outOfForwardedSourcesTimeout}.
      */
     constructor(rtc: RTC, conference: any, track: JitsiRemoteTrack, options: {
-        outOfForwardedSourcesTimeout: number,
-        p2pRtcMuteTimeout: number,
-        rtcMuteTimeout: number
+        outOfForwardedSourcesTimeout: number;
+        p2pRtcMuteTimeout: number;
+        rtcMuteTimeout: number;
     }) {
         this.rtc = rtc;
         this.conference = conference;
             return;
         }
 
-        const sourceName = this.track.getSourceName();
-
         this.figureOutStreamingStatus();
     }
 

modules/detection/DetectionEvents.ts

 export enum DetectionEvents {
-    /**
-     * Event triggered by a audio detector indicating that its active state has changed from active to inactive or vice
-     * versa.
-     * @event
-     * @type {boolean} - true when service has changed to active false otherwise.
-     */
-    DETECTOR_STATE_CHANGE = 'detector_state_change',
 
     /** Event triggered by {@link NoAudioSignalDetector} when the local audio device associated with a JitsiConference
      * starts receiving audio levels with the value of 0 meaning no audio is being captured on that device, or when
      */
     AUDIO_INPUT_STATE_CHANGE = 'audio_input_state_changed',
 
-    /** Event triggered by NoAudioSignalDetector when the local audio device associated with a JitsiConference goes silent
-     * for a period of time, meaning that the device is either broken or hardware/software muted.
+    /**
+     * Event triggered by a audio detector indicating that its active state has changed from active to inactive or vice
+     * versa.
+     * @event
+     * @type {boolean} - true when service has changed to active false otherwise.
+     */
+    DETECTOR_STATE_CHANGE = 'detector_state_change',
+
+    /** Event triggered by NoAudioSignalDetector when the local audio device associated with a JitsiConference goes
+     * silent for a period of time, meaning that the device is either broken or hardware/software muted.
      * @event
      * @type {void}
      */
      *  @type {Object}
      */
     VAD_TALK_WHILE_MUTED = 'detection.vad_talk_while_muted'
-};
+}
 
 // exported for backward compatibility
 export const DETECTOR_STATE_CHANGE = DetectionEvents.DETECTOR_STATE_CHANGE;

modules/e2ee/E2EEErrors.ts

 export enum E2EEErrors {
+    E2EE_SAS_CHANNEL_VERIFICATION_FAILED = 'e2ee.sas.channel-verification-failed',
+    E2EE_SAS_COMMITMENT_MISMATCHED = 'e2ee.sas.commitment-mismatched',
+    E2EE_SAS_INVALID_SAS_VERIFICATION = 'e2ee.sas.invalid-sas-verification',
     E2EE_SAS_KEYS_MAC_MISMATCH = 'e2ee.sas.keys-mac-mismatch',
     E2EE_SAS_MAC_MISMATCH = 'e2ee.sas.mac-mismatch',
-    E2EE_SAS_MISSING_KEY =  'e2ee.sas.missing-key',
-    E2EE_SAS_COMMITMENT_MISMATCHED =  'e2ee.sas.commitment-mismatched',
-    E2EE_SAS_CHANNEL_VERIFICATION_FAILED = 'e2ee.sas.channel-verification-failed',
-    E2EE_SAS_INVALID_SAS_VERIFICATION =  'e2ee.sas.invalid-sas-verification',
+    E2EE_SAS_MISSING_KEY = 'e2ee.sas.missing-key'
 }

modules/e2ee/ManagedKeyHandler.js

      * @param {*} newValue - The property's new value.
      * @private
      */
-    async _onParticipantPropertyChanged(participant, name, oldValue, newValue) {
+    _onParticipantPropertyChanged(participant, name, oldValue, newValue) {
         switch (name) {
         case 'e2ee.idKey':
             logger.debug(`Participant ${participant.getId()} updated their id key: ${newValue}`);

modules/e2ee/Worker.js

-/* global TransformStream */
 /* eslint-disable no-bitwise */
 
 // Worker for E2EE/Insertable streams.
     }
 }
 
-onmessage = async event => {
+onmessage = event => {
     const { operation } = event.data;
 
     if (operation === 'initialize') {

modules/e2ee/crypto-utils.js

     const textEncoder = new TextEncoder();
 
     // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveBits
-    return crypto.subtle.deriveBits({
+    return await crypto.subtle.deriveBits({
         name: 'HKDF',
         salt: textEncoder.encode('JFrameRatchetKey'),
         hash: 'SHA-256',
  */
 export async function importKey(keyBytes) {
     // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey
-    return crypto.subtle.importKey('raw', keyBytes, 'HKDF', false, [ 'deriveBits', 'deriveKey' ]);
+    return await crypto.subtle.importKey('raw', keyBytes, 'HKDF', false, [ 'deriveBits', 'deriveKey' ]);
 }

modules/flags/FeatureFlags.ts

 class FeatureFlags {
     private _runInLiteMode: boolean;
     private _ssrcRewriting: boolean;
-    
+
     /**
      * Configures the module.
      *

modules/litemode/LiteModeContext.js

-/* global TransformStream */
 import { getLogger } from '@jitsi/logger';
 
 import RTCEvents from '../../service/RTC/RTCEvents';

modules/proxyconnection/ProxyConnectionService.js

             this._selfCloseConnection();
         }
 
-        return;
+
     }
 
     /**

modules/proxyconnection/constants.ts

     TERMINATE = 'session-terminate',
     TRANSPORT_INFO = 'transport-info',
     UNAVAILABLE = 'unavailable'
-};
+}

modules/qualitycontrol/MockClasses.ts

         this.videoType = videoType;
     }
 
+    /**
+     * Gets the capture resolution of the mock local track.
+     * @returns - The capture resolution.
+     */
     getCaptureResolution(): number {
         return this.captureResolution;
     }
+
+
     /**
      * Returns the video type of the mock local track.
      * @returns {VideoType}
      * Returns the list of participants.
      * @returns Array<MockParticipant>
      */
-    getParticipants(): Array<MockParticipant>  {
+    getParticipants(): Array<MockParticipant> {
         return this.participants;
     }
 

modules/qualitycontrol/QualityController.ts

 import { getLogger } from '@jitsi/logger';
 
-import JitsiConference from "../../JitsiConference";
-import { JitsiConferenceEvents } from "../../JitsiConferenceEvents";
-import { CodecMimeType } from "../../service/RTC/CodecMimeType";
-import RTCEvents from "../../service/RTC/RTCEvents";
-import JitsiLocalTrack from "../RTC/JitsiLocalTrack";
-import TraceablePeerConnection from "../RTC/TraceablePeerConnection";
-import JingleSessionPC from "../xmpp/JingleSessionPC";
-import { CodecSelection } from "./CodecSelection";
-import ReceiveVideoController from "./ReceiveVideoController";
-import SendVideoController from "./SendVideoController";
+import JitsiConference from '../../JitsiConference';
+import { JitsiConferenceEvents } from '../../JitsiConferenceEvents';
+import { CodecMimeType } from '../../service/RTC/CodecMimeType';
+import RTCEvents from '../../service/RTC/RTCEvents';
 import {
     DEFAULT_LAST_N,
     LAST_N_UNLIMITED,
     VIDEO_CODECS_BY_COMPLEXITY,
     VIDEO_QUALITY_LEVELS
 } from '../../service/RTC/StandardVideoQualitySettings';
+import JitsiLocalTrack from '../RTC/JitsiLocalTrack';
+import TraceablePeerConnection from '../RTC/TraceablePeerConnection';
+import JingleSessionPC from '../xmpp/JingleSessionPC';
+
+import { CodecSelection } from './CodecSelection';
+import ReceiveVideoController from './ReceiveVideoController';
+import SendVideoController from './SendVideoController';
 
 const logger = getLogger(__filename);
 
     BANDWIDTH = 'bandwidth',
     CPU = 'cpu',
     NONE = 'none'
-};
+}
 
 interface IResolution {
     height: number;
     qualityLimitationReason: QualityLimitationReason;
     timestamp: number;
     tpc: TraceablePeerConnection;
-};
+}
 
 interface ITrackStats {
-    encodeResolution: number
+    encodeResolution: number;
     encodeTime: number;
     qualityLimitationReason: QualityLimitationReason;
 }
     sourceName: string;
 }
 
+/* eslint-disable require-jsdoc */
 export class FixedSizeArray {
     private _data: ISourceStats[];
     private _maxSize: number;
-  
+
     constructor(size: number) {
-      this._maxSize = size;
-      this._data = [];
+        this._maxSize = size;
+        this._data = [];
     }
-  
+
     add(item: ISourceStats): void {
-      if (this._data.length >= this._maxSize) {
-        this._data.shift();
-      }
-      this._data.push(item);
+        if (this._data.length >= this._maxSize) {
+            this._data.shift();
+        }
+        this._data.push(item);
     }
-  
+
     get(index: number): ISourceStats | undefined {
-      if (index < 0 || index >= this._data.length) {
-        throw new Error("Index out of bounds");
-      }
-      return this._data[index];
+        if (index < 0 || index >= this._data.length) {
+            throw new Error('Index out of bounds');
+        }
+
+        return this._data[index];
     }
 
     size(): number {
         return this._data.length;
     }
 }
+/* eslint-enable require-jsdoc */
 
 /**
  * QualityController class that is responsible for maintaining optimal video quality experience on the local endpoint
     private _sendVideoController: SendVideoController;
 
     /**
-     * 
+     *
      * @param {JitsiConference} conference - The JitsiConference instance.
      * @param {Object} options - video quality settings passed through config.js.
      */
     constructor(conference: JitsiConference, options: {
         enableAdaptiveMode: boolean;
-        jvb: Object;
+        jvb: object;
         lastNRampupTime: number;
-        p2p: Object;
+        p2p: object;
     }) {
         this._conference = conference;
         const { jvb, p2p } = options;
-        this._codecController = new CodecSelection(conference, { jvb, p2p });
+
+        this._codecController = new CodecSelection(conference, { jvb,
+            p2p });
         this._enableAdaptiveMode = options.enableAdaptiveMode;
         this._encodeTimeStats = new Map();
         this._isLastNRampupBlocked = false;
         const debouncedSelectCodec = this._debounce(
             () => this._codecController.selectPreferredCodec(this._conference.jvbJingleSession),
             1000);
+
         this._conference.on(JitsiConferenceEvents.USER_JOINED, debouncedSelectCodec.bind(this));
         this._conference.on(JitsiConferenceEvents.USER_LEFT, debouncedSelectCodec.bind(this));
         this._conference.rtc.on(
             RTCEvents.SENDER_VIDEO_CONSTRAINTS_CHANGED,
-            (videoConstraints: IVideoConstraints) => this._sendVideoController.onSenderConstraintsReceived(videoConstraints));
+            (videoConstraints: IVideoConstraints) =>
+                this._sendVideoController.onSenderConstraintsReceived(videoConstraints));
         this._conference.on(
             JitsiConferenceEvents.ENCODE_TIME_STATS_RECEIVED,
-            (tpc: TraceablePeerConnection, stats: Map<number, IOutboundRtpStats>) => this._processOutboundRtpStats(tpc, stats));
+            (tpc: TraceablePeerConnection, stats: Map<number, IOutboundRtpStats>) =>
+                this._processOutboundRtpStats(tpc, stats));
     }
 
     /**
      * @param {number} delay - The delay in milliseconds.
      * @returns {Function} - The debounced function.
      */
-    _debounce(func: Function, delay: number) {
-        return function (...args) {
+    _debounce(func: Function, delay: number) { // eslint-disable-line @typescript-eslint/no-unsafe-function-type
+        return function(...args: any) {
+            /* eslint-disable @typescript-eslint/no-invalid-this */
             if (!this._timer) {
                 this._timer = setTimeout(() => {
                     this._timer = null;
                     func.apply(this, args);
                 }, delay);
             }
+            /* eslint-enable @typescript-eslint/no-invalid-this */
         };
     }
 
         if (individualConstraints && Object.keys(individualConstraints).length) {
             for (const value of Object.values(individualConstraints)) {
                 const v: any = value;
+
                 maxHeight = Math.max(maxHeight, v.maxHeight);
             }
         }
                 this._limitedByCpuTimeout = undefined;
                 const updatedStats = this._encodeTimeStats.get(trackId);
                 const latestSourceStats: ISourceStats = updatedStats.get(updatedStats.size() - 1);
+                const expectedSendResolution
+                    = Math.min(localTrack.maxEnabledResolution, localTrack.getCaptureResolution());
 
                 // If the encoder is still limited by CPU, switch to a lower complexity codec.
                 if (latestSourceStats.qualityLimitationReason === QualityLimitationReason.CPU
-                    || encodeResolution <  Math.min(localTrack.maxEnabledResolution, localTrack.getCaptureResolution())) {
-                        return this.codecController.changeCodecPreferenceOrder(localTrack, codec)
+                        || encodeResolution < expectedSendResolution) {
+                    return this.codecController.changeCodecPreferenceOrder(localTrack, codec);
                 }
             }, LIMITED_BY_CPU_TIMEOUT);
         }
         }
     }
 
+    /**
+     * Gets the codec controller instance.
+     */
     get codecController() {
         return this._codecController;
     }
 
+    /**
+     * Gets the receive video controller instance.
+     */
     get receiveVideoController() {
         return this._receiveVideoController;
     }
 
+    /**
+     * Gets the send video controller instance.
+     */
     get sendVideoController() {
         return this._sendVideoController;
     }

modules/sdp/SdpSimulcast.ts

+import * as transform from 'sdp-transform';
+
 import { MediaDirection } from '../../service/RTC/MediaDirection';
 import { MediaType } from '../../service/RTC/MediaType';
 import { SIM_LAYERS, SSRC_GROUP_SEMANTICS } from '../../service/RTC/StandardVideoQualitySettings';
 
-import * as transform from 'sdp-transform';
 
-interface Description {
-    type: RTCSdpType;
+interface IDescription {
     sdp: string;
+    type: RTCSdpType;
 }
 
 /**
      * @param mLine
      * @returns
      */
-     _fillSsrcsFromCache(mLine: transform.MediaDescription) : any {
+    _fillSsrcsFromCache(mLine: transform.MediaDescription): any {
         const mid = mLine.mid;
         const cachedSsrcs = this._ssrcCache.get(mid);
         const newSsrcs = this._parseSimLayers(mLine);
      * @param primarySsrc
      * @returns
      */
-    _generateNewSsrcsForSimulcast(mLine: transform.MediaDescription, primarySsrc: number) : any {
+    _generateNewSsrcsForSimulcast(mLine: transform.MediaDescription, primarySsrc: number): any {
         const cname = this._getSsrcAttribute(mLine, primarySsrc, 'cname');
         let msid = this._getSsrcAttribute(mLine, primarySsrc, 'msid');
-        const addAssociatedAttributes = (mLine: transform.MediaDescription, ssrc: number) => {
-            mLine.ssrcs.push({
-                id: ssrc,
-                attribute: 'cname',
-                value: cname
-            });
-            mLine.ssrcs.push({
-                id: ssrc,
-                attribute: 'msid',
-                value: msid
-            });
-        }
 
         // In Unified-plan mode, the a=ssrc lines with the msid attribute are not present (only cname attributes are
         // present) in the answers that Chrome and Safari generate for an offer received from Jicofo. Generate these
                     attribute: 'msid',
                     value: msid
                 });
-            })
+            });
         }
 
         // Generate SIM layers.
         for (let i = 0; i < this._numOfLayers - 1; ++i) {
             const simSsrc = this._generateSsrc();
 
-            addAssociatedAttributes(mLine, simSsrc);
+            mLine.ssrcs.push({
+                id: simSsrc,
+                attribute: 'cname',
+                value: cname
+            });
+            mLine.ssrcs.push({
+                id: simSsrc,
+                attribute: 'msid',
+                value: msid
+            });
+
             simSsrcs.push(simSsrc);
         }
 
         mLine.ssrcGroups = mLine.ssrcGroups || [];
         mLine.ssrcGroups.push({
             semantics: SSRC_GROUP_SEMANTICS.SIM,
-            ssrcs: primarySsrc + ' ' + simSsrcs.join(' ')
+            ssrcs: `${primarySsrc} ${simSsrcs.join(' ')}`
         });
 
         return mLine;
      *
      * @returns
      */
-    _generateSsrc() : number {
+    _generateSsrc(): number {
         const max = 0xffffffff;
 
         return Math.floor(Math.random() * max);
      * @param attributeName
      * @returns
      */
-    _getSsrcAttribute(mLine: transform.MediaDescription, ssrc: number, attributeName: string) : string | undefined {
+    _getSsrcAttribute(mLine: transform.MediaDescription, ssrc: number, attributeName: string): string | undefined {
         return mLine.ssrcs?.find(
             ssrcInfo => Number(ssrcInfo.id) === ssrc
             && ssrcInfo.attribute === attributeName)?.value;
      * @param mLine
      * @returns
      */
-    _parseSimLayers(mLine: transform.MediaDescription) : Array<number> | null {
+    _parseSimLayers(mLine: transform.MediaDescription): Array<number> | null {
         const simGroup = mLine.ssrcGroups?.find(group => group.semantics === SSRC_GROUP_SEMANTICS.SIM);
 
         if (simGroup) {
      * @param description
      * @returns
      */
-    mungeLocalDescription(description: Description) : Description {
-        if (!description || !description.sdp) {
+    mungeLocalDescription(description: IDescription): IDescription {
+        if (!description?.sdp) {
             return description;
         }
         const session = transform.parse(description.sdp);

modules/statistics/PreCallTest.ts

 import PreCallTest from '@jitsi/precall-test';
 
 
-export interface PreCallResult {
-    throughput: number; // Maximum bandwidth reached in kbps  (kilo bits per second).
-    fractionalLoss: number; // Packet loss percentage over all the test traffic.
-    rtt: number;  // Round trip time in milliseconds.
-    jitter: number;  // Variation in packet arrival times during the transmission of media.
-    mediaConnectivity: boolean; // Whether the data channel was able to send data or not.
+export interface IPreCallResult {
+
+    // Maximum bandwidth reached in kbps  (kilo bits per second).
+    fractionalLoss: number;
+
+    // Round trip time in milliseconds.
+    jitter: number;
+
+    // Variation in packet arrival times during the transmission of media.
+    mediaConnectivity: boolean;
+
+    // Packet loss percentage over all the test traffic.
+    rtt: number;
+    throughput: number; // Whether the data channel was able to send data or not.
 }
 
 // Same interface as a PeerConnection configuration object.
-export interface IceServer {
+export interface IIceServer {
+    credential?: string;
     urls: Array<string> | string;
     username?: string;
-    credential?: string;
 }
 
 /**
  * Run a pre-call test to check the network conditions. It uses a TURN server to establish
- * a connection between two PeerConnections using the server as a relay. Afterwards it sends 
- * some test traffic through a data channel to measure the network conditions, these are 
+ * a connection between two PeerConnections using the server as a relay. Afterwards it sends
+ * some test traffic through a data channel to measure the network conditions, these are
  * recorded and returned through a Promise.
- * 
- * @param {Array<IceServer>} - The ICE servers to use for the test, these are passes to the PeerConnection constructor. 
- * @returns {Promise<PreCallResult | any>} - A Promise that resolves with the test results or rejects with an error.
+ *
+ * @param {Array<IIceServer>} - The ICE servers to use for the test, these are passes to the PeerConnection constructor.
+ * @returns {Promise<IPreCallResult | any>} - A Promise that resolves with the test results or rejects with an error.
  */
-export default async function runPreCallTest(iceServers: Array<IceServer>): Promise<PreCallResult | string> {
-    return new PreCallTest().start(iceServers);
+export default async function runPreCallTest(iceServers: Array<IIceServer>): Promise<IPreCallResult | string> {
+    const test = new PreCallTest();
+
+    return await test.start(iceServers);
 }

modules/version/ComponentsVersions.ts

  * Discovers component versions in a conference.
  */
 export default class ComponentsVersions {
-    versions: {[key: string]: string};
+    versions: { [key: string]: string; };
     conference: any;
 
     /**

modules/videosipgw/VideoSIPGWConstants.ts

 export enum VideoSIPGWStatusConstants {
+
     /**
      * Status that video SIP GW service is available.
      */
     STATUS_AVAILABLE = 'available',
 
     /**
-     * Status that video SIP GW service is not available.
+     * Status that video SIP GW service is available but there are no free nodes
+     * at the moment to serve new requests.
      */
-    STATUS_UNDEFINED = 'undefined',
+    STATUS_BUSY = 'busy',
 
     /**
-     * Status that video SIP GW service is available but there are no free nodes
-     * at the moment to serve new requests.
+     * Status that video SIP GW service is not available.
      */
-    STATUS_BUSY = 'busy'
-};
+    STATUS_UNDEFINED = 'undefined'
+}
 
 export enum VideoSIPGWStateConstants {
+
     /**
-     * Video SIP GW session state, currently running.
+     * Video SIP GW session state, tried to start but it failed.
      */
-    STATE_ON = 'on',
+    STATE_FAILED = 'failed',
 
     /**
      * Video SIP GW session state, currently stopped and not running.
      */
     STATE_OFF = 'off',
 
+    /**
+     * Video SIP GW session state, currently running.
+     */
+    STATE_ON = 'on',
+
     /**
      * Video SIP GW session state, currently is starting.
      */
      * Video SIP GW session state, has observed some issues and is retrying at the
      * moment.
      */
-    STATE_RETRYING = 'retrying',
-
-    /**
-     * Video SIP GW session state, tried to start but it failed.
-     */
-    STATE_FAILED = 'failed'
-};
+    STATE_RETRYING = 'retrying'
+}
 
 export enum VideoSIPGWErrorConstants {
+
     /**
      * Error on trying to create video SIP GW session in conference where
      * there is no room connection (hasn't joined or has left the room).
      * there is an already created session.
      */
     ERROR_SESSION_EXISTS = 'error_session_already_exists'
-};
+}
 
 // exported for backward compatibility
 export const STATUS_AVAILABLE = VideoSIPGWStatusConstants.STATUS_AVAILABLE;

modules/watchRTC/WatchRTC.ts

             // @ts-ignore
             if (browser.isReactNative()) {
                 logger.warn('Cannot initialize WatchRTC in a react native environment!');
+
                 return;
             }
 
             if (!isAnalyticsEnabled(options)) {
                 logger.error('Cannot initialize WatchRTC when analytics or third party requests are disabled.');
+
                 return;
             }
 
     }
 }
 
-export default new WatchRTCHandler();
+export default new WatchRTCHandler();

modules/watchRTC/functions.ts

  */
 export function isAnalyticsEnabled(options): boolean {
     const { analytics, disableThirdPartyRequests } = options;
+
     return !(analytics?.disabled || disableThirdPartyRequests);
 }
 
  */
 export function isRtcstatsEnabled(options): boolean {
     const { analytics } = options;
+
     return analytics?.rtcstatsEnabled ?? false;
 }
 
  */
 export function isWatchRTCEnabled(options): boolean {
     const { analytics } = options;
+
     return analytics?.watchRTCEnabled ?? false;
 }

modules/xmpp/JingleSessionState.ts

 export enum JingleSessionState {
-    /**
-     * The pending Jingle session state which means the session as defined in
-     * XEP-0166(before 'session-invite/session-accept' took place).
-     */
-    PENDING = 'pending',
 
     /**
      * The active Jingle session state as defined in XEP-0166
      * The ended Jingle session state as defined in XEP-0166
      * (after 'session-terminate').
      */
-    ENDED = 'ended'
-};
+    ENDED = 'ended',
+
+    /**
+     * The pending Jingle session state which means the session as defined in
+     * XEP-0166(before 'session-invite/session-accept' took place).
+     */
+    PENDING = 'pending'
+}
 
 // exported for backward compatibility
 export const PENDING = JingleSessionState.PENDING;

modules/xmpp/Lobby.js

 
                     this.lobbyRoom.clean();
 
-                    return;
+
                 }
             });
 

modules/xmpp/MediaSessionEvents.ts

 enum MediaSessionEvents {
+
     /**
      * Event triggered when the remote party signals video max frame heights for its local sources.
      */
     REMOTE_SOURCE_CONSTRAINTS_CHANGED = 'media_session.REMOTE_SOURCE_CONSTRAINTS_CHANGED'
-};
+}
 
-export default MediaSessionEvents;
+export default MediaSessionEvents;

package.json

     "webrtc-adapter": "8.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.16.0",
-    "@babel/eslint-parser": "7.16.0",
-    "@babel/preset-env": "7.16.0",
-    "@babel/preset-typescript": "7.16.7",
-    "@jitsi/eslint-config": "4.1.4",
+    "@babel/core": "7.25.9",
+    "@babel/eslint-parser": "7.25.9",
+    "@babel/preset-env": "7.25.9",
+    "@babel/preset-typescript": "7.25.9",
+    "@jitsi/eslint-config": "5.0.10",
+    "@stylistic/eslint-plugin": "2.12.1",
     "@types/async": "3.2.12",
     "@types/jasmine": "4.0.3",
     "@types/lodash-es": "4.17.12",
     "@types/sdp-transform": "2.4.5",
+    "@typescript-eslint/eslint-plugin": "8.19.1",
+    "@typescript-eslint/parser": "8.19.1",
     "babel-loader": "8.2.3",
     "core-js": "3.19.1",
-    "eslint": "8.1.0",
-    "eslint-plugin-import": "2.25.2",
+    "eslint": "8.57.0",
+    "eslint-plugin-import": "2.31.0",
+    "eslint-plugin-typescript-sort-keys": "3.3.0",
     "jasmine-core": "4.2.0",
     "karma": "6.4.0",
     "karma-chrome-launcher": "3.1.1",

service/RTC/BridgeVideoType.ts

  * @type {{CAMERA: string, DESKTOP: string, DESKTOP_HIGH_FPS: string, NONE: string}}
  */
 export enum BridgeVideoType {
+
     /**
      * The camera video type.
      */

service/RTC/CameraFacingMode.ts

  * @enum {string}
  */
 export enum CameraFacingMode {
+
     /**
      * The mode which specifies the environment-facing camera.
      */

service/RTC/CodecMimeType.ts

  * @type {{AV1: string, H264: string, OPUS: string, RED: string, ULPFEC: string, VP8: string, VP9: string}}
  */
 export enum CodecMimeType {
+
     /**
      * AV1 codec mime type.
      */

service/RTC/MediaDirection.ts

  * Enumeration of the media direction types.
  */
 export enum MediaDirection {
+
     /**
      * Media is send and receive is suspended.
      */

service/RTC/MediaType.ts

 export enum MediaType {
+
     /**
-     * The audio type.
+     * The application type (data over bridge channel).
      */
-    AUDIO = 'audio',
+    APPLICATION = 'application',
 
     /**
-     * The video type.
+     * The audio type.
      */
-    VIDEO = 'video',
+    AUDIO = 'audio',
 
     /**
-     * The application type (data over bridge channel).
+     * The video type.
      */
-    APPLICATION = 'application'
+    VIDEO = 'video'
 }

service/RTC/RTCEvents.ts

 export enum RTCEvents {
+
+    AUDIO_OUTPUT_DEVICE_CHANGED = 'rtc.audio_output_device_changed',
+
+    /**
+     * Designates an event indicating that some received audio SSRCs will now map to
+     * new remote sources.
+     */
+    AUDIO_SSRCS_REMAPPED = 'rtc.audio_ssrcs_remapped',
+
     /**
      * Indicates error while create answer call.
      */
      * Indicates error while create offer call.
      */
     CREATE_OFFER_FAILED = 'rtc.create_offer_failed',
-    DATA_CHANNEL_OPEN = 'rtc.data_channel_open',
     DATA_CHANNEL_CLOSED = 'rtc.data_channel_closed',
-    ENDPOINT_CONN_STATUS_CHANGED = 'rtc.endpoint_conn_status_changed',
+    DATA_CHANNEL_OPEN = 'rtc.data_channel_open',
+    DEVICE_LIST_AVAILABLE = 'rtc.device_list_available',
+
+    DEVICE_LIST_CHANGED = 'rtc.device_list_changed',
+
+    /**
+     * Indicates that the list with available devices will change.
+     */
+    DEVICE_LIST_WILL_CHANGE = 'rtc.device_list_will_change',
+
     DOMINANT_SPEAKER_CHANGED = 'rtc.dominant_speaker_changed',
-    FORWARDED_SOURCES_CHANGED = 'rtc.forwarded_sources_changed',
+
+    ENDPOINT_CONN_STATUS_CHANGED = 'rtc.endpoint_conn_status_changed',
 
     /**
-     * Event emitted when the user granted/blocked a permission for the camera / mic.
-     * Used to keep track of the granted permissions on browsers which don't
-     * support the Permissions API.
+     * Indicates that a message from another participant is received on
+     * data channel.
      */
-    PERMISSIONS_CHANGED = 'rtc.permissions_changed',
+    ENDPOINT_MESSAGE_RECEIVED = 'rtc.endpoint_message_received',
 
-    SENDER_VIDEO_CONSTRAINTS_CHANGED = 'rtc.sender_video_constraints_changed',
+    /**
+     * Indicates that the remote endpoint stats have been received on data channel.
+     */
+    ENDPOINT_STATS_RECEIVED = 'rtc.endpoint_stats_received',
+
+    FORWARDED_SOURCES_CHANGED = 'rtc.forwarded_sources_changed',
 
     /**
      * Event emitted when {@link RTC.setLastN} method is called to update with
      */
     LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED = 'rtc.local_track_max_enabled_resolution_changed',
 
-    TRACK_ATTACHED = 'rtc.track_attached',
+    /**
+     * Designates an event indicating that the local ICE username fragment of
+     * the jingle session has changed.
+     * The first argument of the vent is <tt>TraceablePeerConnection</tt> which
+     * is the source of the event.
+     * The second argument is the actual "ufrag" string.
+     */
+    LOCAL_UFRAG_CHANGED = 'rtc.local_ufrag_changed',
+
+    /**
+     * Event emitted when the user granted/blocked a permission for the camera / mic.
+     * Used to keep track of the granted permissions on browsers which don't
+     * support the Permissions API.
+     */
+    PERMISSIONS_CHANGED = 'rtc.permissions_changed',
 
     /**
      * Event fired when we remote track is added to the conference.
     // (currently implemented for local tracks only)
     REMOTE_TRACK_UNMUTE = 'rtc.remote_track_unmute',
 
-    /**
-     * Indicates error while set local description.
-     */
-    SET_LOCAL_DESCRIPTION_FAILED = 'rtc.set_local_description_failed',
-
-    /**
-     * Indicates error while set remote description.
-     */
-    SET_REMOTE_DESCRIPTION_FAILED = 'rtc.set_remote_description_failed',
-    AUDIO_OUTPUT_DEVICE_CHANGED = 'rtc.audio_output_device_changed',
-    DEVICE_LIST_CHANGED = 'rtc.device_list_changed',
-
-    /**
-     * Indicates that the list with available devices will change.
-     */
-    DEVICE_LIST_WILL_CHANGE = 'rtc.device_list_will_change',
-    DEVICE_LIST_AVAILABLE = 'rtc.device_list_available',
-
-    /**
-     * Indicates that a message from another participant is received on
-     * data channel.
-     */
-    ENDPOINT_MESSAGE_RECEIVED = 'rtc.endpoint_message_received',
-
-    /**
-     * Indicates that the remote endpoint stats have been received on data channel.
-     */
-    ENDPOINT_STATS_RECEIVED = 'rtc.endpoint_stats_received',
-
     /**
      * Designates an event indicating that the local ICE username fragment of
      * the jingle session has changed.
      * is the source of the event.
      * The second argument is the actual "ufrag" string.
      */
-    LOCAL_UFRAG_CHANGED = 'rtc.local_ufrag_changed',
+    REMOTE_UFRAG_CHANGED = 'rtc.remote_ufrag_changed',
+
+    SENDER_VIDEO_CONSTRAINTS_CHANGED = 'rtc.sender_video_constraints_changed',
 
     /**
-     * Designates an event indicating that the local ICE username fragment of
-     * the jingle session has changed.
-     * The first argument of the vent is <tt>TraceablePeerConnection</tt> which
-     * is the source of the event.
-     * The second argument is the actual "ufrag" string.
+     * Indicates error while set local description.
      */
-    REMOTE_UFRAG_CHANGED = 'rtc.remote_ufrag_changed',
+    SET_LOCAL_DESCRIPTION_FAILED = 'rtc.set_local_description_failed',
 
     /**
-     * Designates an event indicating that some received video SSRCs will now map to
-     * new remote sources.
+     * Indicates error while set remote description.
      */
-    VIDEO_SSRCS_REMAPPED = 'rtc.video_ssrcs_remapped',
+    SET_REMOTE_DESCRIPTION_FAILED = 'rtc.set_remote_description_failed',
+
+    TRACK_ATTACHED = 'rtc.track_attached',
 
     /**
-     * Designates an event indicating that some received audio SSRCs will now map to
+     * Designates an event indicating that some received video SSRCs will now map to
      * new remote sources.
      */
-    AUDIO_SSRCS_REMAPPED = 'rtc.audio_ssrcs_remapped'
+    VIDEO_SSRCS_REMAPPED = 'rtc.video_ssrcs_remapped'
 }
 
 export const CREATE_ANSWER_FAILED = RTCEvents.CREATE_ANSWER_FAILED;
 // TODO: this was a pre-ES6 module using module.exports = RTCEvents which doesn't translate well
 // it is used in a number of places and should be updated to use the named export
 
-export default RTCEvents;
+export default RTCEvents;

service/RTC/SignalingEvents.ts

 export enum SignalingEvents {
+
     /**
      * Event triggered when participant's muted status changes.
      *

service/RTC/StandardVideoQualitySettings.ts

 import browser from '../../modules/browser';
+
 import { CodecMimeType } from './CodecMimeType';
 
 // Default value for assumed downlink bandwidth for the local endpoint which tells the bridge to use its own calculated
  * The ssrc-group semantics for SSRCs related to the video streams.
  */
 export enum SSRC_GROUP_SEMANTICS {
+
     // The semantics for group of SSRCs belonging to the same stream, primary and RTX.
     FID = 'FID',
 
  * next codec in the list.
  */
 export const VIDEO_CODECS_BY_COMPLEXITY = {
-    'camera' : [
+    'camera': [
         CodecMimeType.AV1,
         CodecMimeType.VP9,
         CodecMimeType.VP8
     ],
-    'desktop' : [
+    'desktop': [
         CodecMimeType.VP9,
         CodecMimeType.VP8,
         CodecMimeType.AV1
  * Enumerate the supported video resolutions.
  */
 export enum VIDEO_QUALITY_SETTINGS {
-    // 3840x2160 or 4k.
-    ULTRA = 'ultraHd',
 
     // 1920x1080 or full High Definition.
     FULL = 'fullHd',
     // 1280x720 or High Definition.
     HIGH = 'high',
 
-    // 640x360 or Standard Definition.
-    STANDARD = 'standard',
-
     // 320x180 or Low Definition.
     LOW = 'low',
 
     // When the camera is turned off.
-    NONE = 'none'
+    NONE = 'none',
+
+    // 640x360 or Standard Definition.
+    STANDARD = 'standard',
+
+    // 3840x2160 or 4k.
+    ULTRA = 'ultraHd'
 }

service/RTC/VideoEncoderScalabilityMode.ts

  * }
  */
 export enum VideoEncoderScalabilityMode {
+
     /**
      * L1T3 mode: 1-layer spatial and 3-layer temporal scalabilty encoding.
      */

service/RTC/VideoType.ts

  * Enumeration of the video types
  */
 export enum VideoType {
+
     /**
      * The camera video type.
      */

service/connectivity/ConnectionQualityEvents.ts

 export enum ConnectionQualityEvents {
+
     /**
      * Indicates that the local connection statistics were updated.
      */
      * were updated.
      */
     REMOTE_STATS_UPDATED = 'cq.remote_stats_updated'
-};
+}
 
 // exported for backward compatibility
 export const LOCAL_STATS_UPDATED = ConnectionQualityEvents.LOCAL_STATS_UPDATED;

service/e2eping/E2ePingEvents.ts

 export enum E2ePingEvents {
+
     /**
      * Indicates that the end-to-end round-trip-time for a participant has changed.
      */
     E2E_RTT_CHANGED = 'e2eping.e2e_rtt_changed'
-};
+}
 
 // exported for backward compatibility
 export const E2E_RTT_CHANGED = E2ePingEvents.E2E_RTT_CHANGED;

service/statistics/AnalyticsEvents.ts

  */
 
 export enum AnalyticsEvents {
-    /**
-     * The constant which identifies an event of type "operational".
-     */
-    TYPE_OPERATIONAL = 'operational',
-
-    /**
-     * The constant which identifies an event of type "page".
-     */
-    TYPE_PAGE = 'page',
-
-    /**
-     * The constant which identifies an event of type "track".
-     */
-    TYPE_TRACK = 'track',
-
-    /**
-     * The constant which identifies an event of type "ui".
-     */
-    TYPE_UI = 'ui',
 
     /**
      * The "action" value for Jingle events which indicates that the Jingle session
     ACTION_JVB_ICE_FAILED = 'jvb.ice.failed',
 
     /**
-     * The "action" value for P2P events which indicates that P2P session initiate message has been rejected by the client
-     * because the mandatory requirements were not met.
+     * The "action" value for P2P events which indicates that P2P session initiate message has been rejected by the
+     * client because the mandatory requirements were not met.
      */
     ACTION_P2P_DECLINED = 'decline',
 
      */
     TRACK_UNMUTED = 'track.unmuted',
 
+    /**
+     * The constant which identifies an event of type "operational".
+     */
+    TYPE_OPERATIONAL = 'operational',
+
+    /**
+     * The constant which identifies an event of type "page".
+     */
+    TYPE_PAGE = 'page',
+
+    /**
+     * The constant which identifies an event of type "track".
+     */
+    TYPE_TRACK = 'track',
+
+    /**
+     * The constant which identifies an event of type "ui".
+     */
+    TYPE_UI = 'ui',
+
     /**
      * Indicates that the video codec changed for a local track.
      *
  * Creates an operational event which indicates that we have received a
  * "bridge down" event from jicofo.
  */
-export const createBridgeDownEvent = () => ( {
-    action: 'bridge.down',
-    actionSubject: 'bridge.down',
-    type: TYPE_OPERATIONAL
-} );
+export const createBridgeDownEvent = () => {
+    return {
+        action: 'bridge.down',
+        actionSubject: 'bridge.down',
+        type: TYPE_OPERATIONAL
+    };
+};
 
 /**
  * Creates an event which indicates that the XMPP connection failed
  * @param errorMessage TODO
  * @param detail connection failed details.
  */
-export const createConnectionFailedEvent = ( errorType: unknown, errorMessage: unknown, details: object ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action: 'connection.failed',
-    attributes: {
-        'error_type': errorType,
-        'error_message': errorMessage,
-        ...details
-    }
-} );
+export const createConnectionFailedEvent = (errorType: unknown, errorMessage: unknown, details: object) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        action: 'connection.failed',
+        attributes: {
+            'error_type': errorType,
+            'error_message': errorMessage,
+            ...details
+        }
+    };
+};
 
 /**
  * Creates a conference event.
  * @param action - The action of the event.
  * @param attributes - The attributes to be added to the event.
  */
-export const createConferenceEvent = ( action: string, attributes: object ) => ( {
-    action,
-    attributes,
-    source: 'conference',
-    type: AnalyticsEvents.TYPE_OPERATIONAL
-} );
+export const createConferenceEvent = (action: string, attributes: object) => {
+    return {
+        action,
+        attributes,
+        source: 'conference',
+        type: AnalyticsEvents.TYPE_OPERATIONAL
+    };
+};
 
 /**
  * Creates an operational event which indicates that a particular connection
  * relative to the beginning of the document's lifetime.
  *
  */
-export const createConnectionStageReachedEvent = ( stage: unknown, attributes: object ) => ( {
-    action: 'connection.stage.reached',
-    actionSubject: stage,
-    attributes,
-    source: 'connection.stage.reached',
-    type: AnalyticsEvents.TYPE_OPERATIONAL
-} );
+export const createConnectionStageReachedEvent = (stage: unknown, attributes: object) => {
+    return {
+        action: 'connection.stage.reached',
+        actionSubject: stage,
+        attributes,
+        source: 'connection.stage.reached',
+        type: AnalyticsEvents.TYPE_OPERATIONAL
+    };
+};
 
 /**
  * Creates an operational event for the end-to-end round trip time to a
  * @param region the region of the remote participant
  * @param rtt the rtt
  */
-export const createE2eRttEvent = ( participantId: unknown, region: unknown, rtt: unknown ) => ( {
-    attributes: {
-        'participant_id': participantId,
-        region,
-        rtt
-    },
-    name: 'e2e_rtt',
-    type: AnalyticsEvents.TYPE_OPERATIONAL
-} );
+export const createE2eRttEvent = (participantId: unknown, region: unknown, rtt: unknown) => {
+    return {
+        attributes: {
+            'participant_id': participantId,
+            region,
+            rtt
+        },
+        name: 'e2e_rtt',
+        type: AnalyticsEvents.TYPE_OPERATIONAL
+    };
+};
 
 /**
  * Creates an event which indicates that the focus has left the MUC.
  */
-export const createFocusLeftEvent = () => ( {
-    action: 'focus.left',
-    actionSubject: 'focus.left',
-    type: AnalyticsEvents.TYPE_OPERATIONAL
-} );
+export const createFocusLeftEvent = () => {
+    return {
+        action: 'focus.left',
+        actionSubject: 'focus.left',
+        type: AnalyticsEvents.TYPE_OPERATIONAL
+    };
+};
 
 /**
  * Creates an event related to a getUserMedia call.
  * 'success', 'warning', etc.
  * @param attributes the attributes to attach to the event.
  */
-export const createGetUserMediaEvent = ( action: 'error' | 'success' | 'warning' | string, attributes: object = {} ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    source: 'get.user.media',
-    action,
-    attributes
-} );
+export const createGetUserMediaEvent = (action: 'error' | 'success' | 'warning' | string, attributes: object = {}) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        source: 'get.user.media',
+        action,
+        attributes
+    };
+};
 
 /**
  * Creates an event which indicates that the JVB ICE connection has failed event after 3 retries.
  * @param attributes - The attributes to be added to the event.
  * @returns - The event object.
  */
-export const createJvbIceFailedEvent = ( action: unknown, attributes: object = {} ) => ( {
-    action,
-    attributes,
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-} );
+export const createJvbIceFailedEvent = (action: unknown, attributes: object = {}) => {
+    return {
+        action,
+        attributes,
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+    };
+};
 
 /**
  * Creates an event related to remote participant connection status changes.
  *
  * @param attributes the attributes to attach to the event.
  */
-export const createParticipantConnectionStatusEvent = ( attributes: object = {} ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    source: 'peer.conn.status',
-    action: 'duration',
-    attributes
-} );
+export const createParticipantConnectionStatusEvent = (attributes: object = {}) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        source: 'peer.conn.status',
+        action: 'duration',
+        attributes
+    };
+};
 
 /**
  * Creates an event related to remote track streaming status changes.
  *
  * @param attributes the attributes to attach to the event.
  */
-export const createTrackStreamingStatusEvent = ( attributes: object = {} ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    source: 'track.streaming.status',
-    action: 'duration',
-    attributes
-} );
+export const createTrackStreamingStatusEvent = (attributes: object = {}) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        source: 'track.streaming.status',
+        action: 'duration',
+        attributes
+    };
+};
 
 /**
  * Creates an event for a Jingle-related event.
  * @param action the action of the event
  * @param attributes attributes to add to the event.
  */
-export const createJingleEvent = ( action: unknown, attributes: object = {} ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action,
-    source: 'jingle',
-    attributes
-} );
+export const createJingleEvent = (action: unknown, attributes: object = {}) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        action,
+        source: 'jingle',
+        attributes
+    };
+};
 
 /**
  * Creates an event which indicates that a local track was not able to read
  * @param mediaType the media type of the local track ('audio' or
  * 'video').
  */
-export const createNoDataFromSourceEvent = ( mediaType: 'audio' | 'video' | string, value: unknown ) => ( {
-    attributes: {
-        'media_type': mediaType,
-        value
-    },
-    action: 'track.no.data.from.source',
-    type: AnalyticsEvents.TYPE_OPERATIONAL
-} );
+export const createNoDataFromSourceEvent = (mediaType: 'audio' | 'video' | string, value: unknown) => {
+    return {
+        attributes: {
+            'media_type': mediaType,
+            value
+        },
+        action: 'track.no.data.from.source',
+        type: AnalyticsEvents.TYPE_OPERATIONAL
+    };
+};
 
 /**
  * Creates an event for a p2p-related event.
  * @param action the action of the event
  * @param attributes attributes to add to the event.
  */
-export const createP2PEvent = ( action: unknown, attributes: object = {} ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action,
-    source: 'p2p',
-    attributes
-} )
+export const createP2PEvent = (action: unknown, attributes: object = {}) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        action,
+        source: 'p2p',
+        attributes
+    };
+};
 
 /**
  * Indicates that we received a remote command to mute.
  */
-export const createRemotelyMutedEvent = ( mediaType: unknown ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action: 'remotely.muted',
-    mediaType
-} );
+export const createRemotelyMutedEvent = (mediaType: unknown) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        action: 'remotely.muted',
+        mediaType
+    };
+};
 
 /**
  * Creates an event which contains RTP statistics such as RTT and packet loss.
  * {@link TraceablePeerConnection} and work independently from the main stats
  * pipe.
  */
-export const createRtpStatsEvent = ( attributes: object ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action: 'rtp.stats',
-    attributes
-} );
+export const createRtpStatsEvent = (attributes: object) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        action: 'rtp.stats',
+        attributes
+    };
+};
 
 /**
  * Creates an event which contains the round trip time (RTT) to a set of
  *
  * @param attributes
  */
-export const createRttByRegionEvent = ( attributes: object ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action: 'rtt.by.region',
-    attributes
-} );
+export const createRttByRegionEvent = (attributes: object) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        action: 'rtt.by.region',
+        attributes
+    };
+};
 
 /**
  * Creates an event which contains the local and remote ICE candidate types
  *
  * @param attributes
  */
-export const createTransportStatsEvent = ( attributes: object ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action: 'transport.stats',
-    attributes
-} );
+export const createTransportStatsEvent = (attributes: object) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        action: 'transport.stats',
+        attributes
+    };
+};
 
 /**
  * Creates an event which contains information about the audio output problem (the user id of the affected participant,
  * @param localAudioLevels - The local audio levels.
  * @param remoteAudioLevels - The audio levels received from the participant.
  */
-export const createAudioOutputProblemEvent = ( userID: string, localAudioLevels: unknown, remoteAudioLevels: unknown ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action: 'audio.output.problem',
-    attributes: {
-        userID,
-        localAudioLevels,
-        remoteAudioLevels
-    }
-} );
+export const createAudioOutputProblemEvent
+    = (userID: string, localAudioLevels: unknown, remoteAudioLevels: unknown) => {
+        return {
+            type: AnalyticsEvents.TYPE_OPERATIONAL,
+            action: 'audio.output.problem',
+            attributes: {
+                userID,
+                localAudioLevels,
+                remoteAudioLevels
+            }
+        };
+    };
 
 /**
  * Creates an event which contains an information related to the bridge channel close event.
  * @param code - A code from {@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
  * @param reason - A string which describes the reason for closing the bridge channel.
  */
-export const createBridgeChannelClosedEvent = ( code: string, reason: string ) => ( {
-    type: AnalyticsEvents.TYPE_OPERATIONAL,
-    action: 'bridge-channel.error',
-    attributes: {
-        code,
-        reason
-    }
-} );
+export const createBridgeChannelClosedEvent = (code: string, reason: string) => {
+    return {
+        type: AnalyticsEvents.TYPE_OPERATIONAL,
+        action: 'bridge-channel.error',
+        attributes: {
+            code,
+            reason
+        }
+    };
+};
 
 /**
  * Creates an event which indicates the Time To First Media (TTFM).
  *      muted: whether the track has ever been muted (?)
  *      value: the TTMF in milliseconds.
  */
-export const createTtfmEvent = ( attributes: object ) => createConnectionStageReachedEvent( 'ttfm', attributes );
+export const createTtfmEvent = (attributes: object) => createConnectionStageReachedEvent('ttfm', attributes);

service/statistics/Events.ts

 export enum Events {
+
     /**
      * Notifies about audio level in RTP statistics by SSRC.
      *
      * An event carrying performance stats.
      */
     LONG_TASKS_STATS = 'statistics.long_tasks_stats'
-};
+}
 
 // exported for backward compatibility
 export const AUDIO_LEVEL = Events.AUDIO_LEVEL;

service/statistics/constants.ts

-export const LOCAL_JID = 'local'
+export const LOCAL_JID = 'local';

service/xmpp/XMPPEvents.ts

 export enum XMPPEvents {
+
     /**
      * Indicates error while adding ice candidate.
      */
     // audio.
     AUDIO_MUTED_BY_FOCUS = 'xmpp.audio_muted_by_focus',
 
-    // Designates an event indicating that the focus has asked us to disable our
-    // camera.
-    VIDEO_MUTED_BY_FOCUS = 'xmpp.video_muted_by_focus',
     AUTHENTICATION_REQUIRED = 'xmpp.authentication_required',
+
+    /**
+     * Event fired when we receive a message for AV moderation approved for the local participant.
+     */
+    AV_MODERATION_APPROVED = 'xmpp.av_moderation.approved',
+
+    /**
+     * Event fired when the moderation enable/disable changes.
+     */
+    AV_MODERATION_CHANGED = 'xmpp.av_moderation.changed',
+
+    /**
+     * Event fired when we receive message that a new jid was approved.
+     */
+    AV_MODERATION_PARTICIPANT_APPROVED = 'xmpp.av_moderation.participant.approved',
+
+    /**
+     * Event fired when we receive message that a new jid was approved.
+     */
+    AV_MODERATION_PARTICIPANT_REJECTED = 'xmpp.av_moderation.participant.rejected',
+
+    /**
+     * Event fired when we receive a message for AV moderation.
+     */
+    AV_MODERATION_RECEIVED = 'xmpp.av_moderation.received',
+
+    /**
+    * Event fired when we receive a message for AV moderation rejected for the local participant.
+    */
+    AV_MODERATION_REJECTED = 'xmpp.av_moderation.rejected',
+
+    /**
+     * Event fired when we receive a message for breakout rooms.
+     */
+    BREAKOUT_ROOMS_EVENT = 'xmpp.breakout-rooms.event',
+
+    /**
+     * Event fired when a participant is requested to join a given (breakout) room.
+     */
+    BREAKOUT_ROOMS_MOVE_TO_ROOM = 'xmpp.breakout-rooms.move-to-room',
+
+    /**
+     * Event fired when the breakout rooms data was updated.
+     */
+    BREAKOUT_ROOMS_UPDATED = 'xmpp.breakout-rooms.updated',
+
     BRIDGE_DOWN = 'xmpp.bridge_down',
 
     /**
      */
     CALL_ACCEPTED = 'xmpp.callaccepted.jingle',
 
-    // Designates an event indicating that an offer (e.g. Jingle
-    // session-initiate) was received.
-    CALL_INCOMING = 'xmpp.callincoming.jingle',
-
     // Triggered when Jicofo kills our media session, this can happen while
     // we're still in the MUC, when it decides to terminate the media session.
     // For example when the session is idle for too long, because we're the only
     // person in the conference room.
     CALL_ENDED = 'xmpp.callended.jingle',
+
+    // Designates an event indicating that an offer (e.g. Jingle
+    // session-initiate) was received.
+    CALL_INCOMING = 'xmpp.callincoming.jingle',
+
     CHAT_ERROR_RECEIVED = 'xmpp.chat_error_received',
-    SETTINGS_ERROR_RECEIVED = 'xmpp.settings_error_received',
 
     // The conference properties (as advertised by jicofo) have changed
     CONFERENCE_PROPERTIES_CHANGED = 'xmpp.conference_properties_changed',
 
+    /**
+     * Event fired when conference creation timestamp is received.
+     */
+    CONFERENCE_TIMESTAMP_RECEIVED = 'xmpp.conference_timestamp_received',
+
     /**
      * This event is triggered when the ICE connects for the first time.
      */
     // failed.
     CONNECTION_FAILED = 'xmpp.connection.failed',
 
-    // Designates an event indicating that the media (ICE) connection was
-    // interrupted. This should go to the RTC module.
-    CONNECTION_INTERRUPTED = 'xmpp.connection.interrupted',
-
-    // Designates an event indicating that the media (ICE) connection was
-    // restored. This should go to the RTC module.
-    CONNECTION_RESTORED = 'xmpp.connection.restored',
-
     // Designates an event indicating that the media (ICE) connection failed.
     // This should go to the RTC module.
     CONNECTION_ICE_FAILED = 'xmpp.connection.ice.failed',
 
+    // Designates an event indicating that the media (ICE) connection was
+    // interrupted. This should go to the RTC module.
+    CONNECTION_INTERRUPTED = 'xmpp.connection.interrupted',
+
     // Designates an event indicating that the call has been migrated to a different
     // bridge and that the client needs to be restarted for a successful transition.
     CONNECTION_RESTARTED = 'xmpp.connection.restart',
 
+    // Designates an event indicating that the media (ICE) connection was
+    // restored. This should go to the RTC module.
+    CONNECTION_RESTORED = 'xmpp.connection.restored',
+
     /**
      * Designates an event indicating connection status changes.
      */
      * Chat room instance have been removed from Strophe.emuc plugin.
      */
     EMUC_ROOM_REMOVED = 'xmpp.emuc_room_removed',
+
     ETHERPAD = 'xmpp.etherpad',
+
     FOCUS_DISCONNECTED = 'xmpp.focus_disconnected',
+
     FOCUS_LEFT = 'xmpp.focus_left',
+
     GRACEFUL_SHUTDOWN = 'xmpp.graceful_shutdown',
 
+    // Designates an event indicating that the local ICE connection state has
+    // changed.
+    ICE_CONNECTION_STATE_CHANGED = 'xmpp.ice_connection_state_changed',
+
+    // Designates an event indicating that an invite XMPP message in the MUC was
+    // received.
+    INVITE_MESSAGE_RECEIVED = 'xmpp.invite_message_received',
+
+    /**
+     * Event which is emitted when the body in an XMPP message in the MUC
+     * contains JSON
+     * TODO: this event contains a typo (xmmp vs xmpp) but it's unlikely this can be changed now
+     */
+    JSON_MESSAGE_RECEIVED = 'xmmp.json_message_received',
+
     /**
      * Designates an event indicating that we were kicked from the XMPP MUC.
      * @param {boolean} isSelfPresence - whether it is for local participant
     // received.
     MESSAGE_RECEIVED = 'xmpp.message_received',
 
-    // Designates an event indicating that a reaction XMPP message in the MUC
-    // was received.
-    REACTION_RECEIVED = "xmpp.reaction_received",
-
-    // Designates an event indicating that an invite XMPP message in the MUC was
-    // received.
-    INVITE_MESSAGE_RECEIVED = 'xmpp.invite_message_received',
-
-    // Designates an event indicating that a private XMPP message in the MUC was
-    // received.
-    PRIVATE_MESSAGE_RECEIVED = 'xmpp.private_message_received',
-
-    // Designates an event indicating that a bot participant type had changed
-    MUC_MEMBER_BOT_TYPE_CHANGED = 'xmpp.muc_member_bot_type_changed',
+    // Designates an event indicating that a participant was denied access to a conference from the lobby XMPP MUC.
+    MUC_DENIED_ACCESS = 'xmpp.muc_denied access',
 
     // Designates an event indicating that the XMPP MUC was destroyed.
     MUC_DESTROYED = 'xmpp.muc_destroyed',
 
-    // Designates an event indicating that we are currently in process of joining the XMPP MUC.
-    MUC_JOIN_IN_PROGRESS = 'xmpp.muc_join_in_progress',
-
     // Designates an event indicating that we have joined the XMPP MUC.
     MUC_JOINED = 'xmpp.muc_joined',
 
-    // Designates an event indicating that a participant joined the XMPP MUC.
-    MUC_MEMBER_JOINED = 'xmpp.muc_member_joined',
+    // Designates an event indicating that we are currently in process of joining the XMPP MUC.
+    MUC_JOIN_IN_PROGRESS = 'xmpp.muc_join_in_progress',
 
-    // Designates an event indicating that a participant left the XMPP MUC.
-    MUC_MEMBER_LEFT = 'xmpp.muc_member_left',
+    // Designates an event indicating that local participant left the muc
+    MUC_LEFT = 'xmpp.muc_left',
 
     // Designates an event indicating that a participant joined the lobby XMPP MUC.
     MUC_LOBBY_MEMBER_JOINED = 'xmpp.muc_lobby_member_joined',
 
-    // Designates an event indicating that a participant in the lobby XMPP MUC has been updated
-    MUC_LOBBY_MEMBER_UPDATED = 'xmpp.muc_lobby_member_updated',
-
     // Designates an event indicating that a participant left the XMPP MUC.
     MUC_LOBBY_MEMBER_LEFT = 'xmpp.muc_lobby_member_left',
 
-    // Designates an event indicating that a participant was denied access to a conference from the lobby XMPP MUC.
-    MUC_DENIED_ACCESS = 'xmpp.muc_denied access',
-
-    // Designates an event indicating that local participant left the muc
-    MUC_LEFT = 'xmpp.muc_left',
-
-    // Designates an event indicating that the MUC role of a participant has
-    // changed.
-    MUC_ROLE_CHANGED = 'xmpp.muc_role_changed',
+    // Designates an event indicating that a participant in the lobby XMPP MUC has been updated
+    MUC_LOBBY_MEMBER_UPDATED = 'xmpp.muc_lobby_member_updated',
 
     // Designates an event indicating that the MUC has been locked or unlocked.
     MUC_LOCK_CHANGED = 'xmpp.muc_lock_changed',
     // Designates an event indicating that the MUC members only config has changed.
     MUC_MEMBERS_ONLY_CHANGED = 'xmpp.muc_members_only_changed',
 
+    // Designates an event indicating that a bot participant type had changed
+    MUC_MEMBER_BOT_TYPE_CHANGED = 'xmpp.muc_member_bot_type_changed',
+
+    // Designates an event indicating that a participant joined the XMPP MUC.
+    MUC_MEMBER_JOINED = 'xmpp.muc_member_joined',
+
+    // Designates an event indicating that a participant left the XMPP MUC.
+    MUC_MEMBER_LEFT = 'xmpp.muc_member_left',
+
+    // Designates an event indicating that the MUC role of a participant has
+    // changed.
+    MUC_ROLE_CHANGED = 'xmpp.muc_role_changed',
+
     // Designates an event indicating that the MUC visitors support has changed.
     MUC_VISITORS_SUPPORTED_CHANGED = 'xmpp.muc_visitors_supported_changed',
 
     // advertised that they have audio muted (or unmuted).
     PARTICIPANT_AUDIO_MUTED = 'xmpp.audio_muted',
 
+    /**
+     * Indicates that the features of the participant has been changed.
+     */
+    PARTICIPANT_FEATURES_CHANGED = 'xmpp.participant_features_changed',
+
     // Designates an event indicating that a participant in the XMPP MUC has
     // advertised that they have video muted (or unmuted).
     PARTICIPANT_VIDEO_MUTED = 'xmpp.video_muted',
     // someone (regardless of whether or not the "video type" changed).
     PARTICIPANT_VIDEO_TYPE_CHANGED = 'xmpp.video_type',
 
-    /**
-     * Indicates that the features of the participant has been changed.
-     */
-    PARTICIPANT_FEATURES_CHANGED = 'xmpp.participant_features_changed',
     PASSWORD_REQUIRED = 'xmpp.password_required',
 
     /**
     PHONE_NUMBER_CHANGED = 'conference.phoneNumberChanged',
     PRESENCE_RECEIVED = 'xmpp.presence_received',
     PRESENCE_STATUS = 'xmpp.presence_status',
+
+    // Designates an event indicating that a private XMPP message in the MUC was
+    // received.
+    PRIVATE_MESSAGE_RECEIVED = 'xmpp.private_message_received',
     PROMPT_FOR_LOGIN = 'xmpp.prompt_for_login',
 
+    // Designates an event indicating that a reaction XMPP message in the MUC
+    // was received.
+    REACTION_RECEIVED = 'xmpp.reaction_received',
+
     // xmpp is connected and obtained user media
     READY_TO_JOIN = 'xmpp.ready_to_join',
 
      * Indicates that the offer / answer renegotiation has failed.
      */
     RENEGOTIATION_FAILED = 'xmpp.renegotiation_failed',
+
     RESERVATION_ERROR = 'xmpp.room_reservation_error',
+
     ROOM_CONNECT_ERROR = 'xmpp.room_connect_error',
-    ROOM_CONNECT_NOT_ALLOWED_ERROR = 'xmpp.room_connect_error.not_allowed',
-    ROOM_JOIN_ERROR = 'xmpp.room_join_error',
+
     ROOM_CONNECT_MEMBERS_ONLY_ERROR = 'xmpp.room_connect_error.members_only',
 
+    ROOM_CONNECT_NOT_ALLOWED_ERROR = 'xmpp.room_connect_error.not_allowed',
+
+    ROOM_DISCO_INFO_FAILED = 'xmpp.room_disco_info_failed',
+
     /**
      * Indicates that we have received a reply to our disco-info request for the room.
      */
     ROOM_DISCO_INFO_UPDATED = 'xmpp.room_disco_info_updated',
-    ROOM_DISCO_INFO_FAILED = 'xmpp.room_disco_info_failed',
+
+    ROOM_JOIN_ERROR = 'xmpp.room_join_error',
 
     /**
      * Indicates that max users limit has been reached.
      */
     ROOM_MAX_USERS_ERROR = 'xmpp.room_max_users_error',
 
+    /**
+     * Event fired when we receive a message related to room metadata.
+     */
+    ROOM_METADATA_EVENT = 'xmpp.room-metadata.event',
+
+    /**
+     * Event fired when we receive a message related to room metadata.
+     */
+    ROOM_METADATA_UPDATED = 'xmpp.room-metadata.updated',
+
     // Designates an event indicating that we sent an XMPP message to the MUC.
     SENDING_CHAT_MESSAGE = 'xmpp.sending_chat_message',
 
      */
     SESSION_ACCEPT_TIMEOUT = 'xmpp.session_accept_timeout',
 
+    SETTINGS_ERROR_RECEIVED = 'xmpp.settings_error_received',
+
     /**
      * Event fired when participant joins a meeting without audio.
      */
      */
     SPEAKER_STATS_RECEIVED = 'xmpp.speaker_stats_received',
 
-    /**
-     * Event fired when conference creation timestamp is received.
-     */
-    CONFERENCE_TIMESTAMP_RECEIVED = 'xmpp.conference_timestamp_received',
-
-    /**
-     * Event fired when we receive a message for AV moderation approved for the local participant.
-     */
-    AV_MODERATION_APPROVED = 'xmpp.av_moderation.approved',
-
-    /**
-    * Event fired when we receive a message for AV moderation rejected for the local participant.
-    */
-    AV_MODERATION_REJECTED = 'xmpp.av_moderation.rejected',
-
-    /**
-     * Event fired when we receive a message for AV moderation.
-     */
-    AV_MODERATION_RECEIVED = 'xmpp.av_moderation.received',
-
-    /**
-     * Event fired when the moderation enable/disable changes.
-     */
-    AV_MODERATION_CHANGED = 'xmpp.av_moderation.changed',
-
-    /**
-     * Event fired when we receive message that a new jid was approved.
-     */
-    AV_MODERATION_PARTICIPANT_APPROVED = 'xmpp.av_moderation.participant.approved',
-
-    /**
-     * Event fired when we receive message that a new jid was approved.
-     */
-    AV_MODERATION_PARTICIPANT_REJECTED = 'xmpp.av_moderation.participant.rejected',
-
-    /**
-     * Event fired when a participant is requested to join a given (breakout) room.
-     */
-    BREAKOUT_ROOMS_MOVE_TO_ROOM = 'xmpp.breakout-rooms.move-to-room',
-
-    /**
-     * Event fired when we receive a message for breakout rooms.
-     */
-    BREAKOUT_ROOMS_EVENT = 'xmpp.breakout-rooms.event',
-
-    /**
-     * Event fired when the breakout rooms data was updated.
-     */
-    BREAKOUT_ROOMS_UPDATED = 'xmpp.breakout-rooms.updated',
-
-    /**
-     * Event fired when we receive a message related to room metadata.
-     */
-    ROOM_METADATA_EVENT = 'xmpp.room-metadata.event',
-
-    /**
-     * Event fired when we receive a message related to room metadata.
-     */
-    ROOM_METADATA_UPDATED = 'xmpp.room-metadata.updated',
-
     // Designates an event indicating that we should join the conference with
     // audio and/or video muted.
     START_MUTED_FROM_FOCUS = 'xmpp.start_muted_from_focus',
      */
     TRANSPORT_INFO = 'xmpp.transportinfo.jingle',
 
+    // Designates an event indicating that the focus has asked us to disable our
+    // camera.
+    VIDEO_MUTED_BY_FOCUS = 'xmpp.video_muted_by_focus',
+
     /**
      * Indicates that video SIP GW state changed.
      *
      */
     VISITORS_REJECTION = 'xmpp.visitors_rejection',
 
-    // Designates an event indicating that the local ICE connection state has
-    // changed.
-    ICE_CONNECTION_STATE_CHANGED = 'xmpp.ice_connection_state_changed',
-
-    /**
-     * Event which is emitted when the body in an XMPP message in the MUC
-     * contains JSON
-     * TODO: this event contains a typo (xmmp vs xmpp) but it's unlikely this can be changed now
-     */
-    JSON_MESSAGE_RECEIVED = 'xmmp.json_message_received'
-};
+}

service/xmpp/XMPPExtensioProtocols.ts

 
 export enum XEP {
+
     /**
      * XEP-0338 - Signals the usage of bundled media, i.e., allows the use of a single set of ICE candidates for
      * multiple media descriptions.
      */
     RTP_FEEDBACK = 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0',
 
-    /**
-     * XEP-0167 - Signals support for RTP video.
-     * https://xmpp.org/extensions/xep-0167.html#support
-     */
-    RTP_VIDEO = 'urn:xmpp:jingle:apps:rtp:video',
-
     /**
      * XEP-0294 - Signals the use of RTP Header Extensions.
      * https://xmpp.org/extensions/xep-0294.html
      */
     RTP_MEDIA = 'urn:xmpp:jingle:apps:rtp:1',
 
+    /**
+     * XEP-0167 - Signals support for RTP video.
+     * https://xmpp.org/extensions/xep-0167.html#support
+     */
+    RTP_VIDEO = 'urn:xmpp:jingle:apps:rtp:video',
+
     /**
      * XEP-0343 - Signaling WebRTC datachannels (bridge channel) in Jingle that uses DTLS/SCTP on top of ICE.
      * https://xmpp.org/extensions/xep-0343.html

webpack.config.js

         = sharedConfig(mode === 'production' /* minimize */, Boolean(process.env.ANALYZE_BUNDLE) /* analyzeBundle */);
 
     return [
-        Object.assign({}, config, {
+        { ...config,
             entry: {
                 'lib-jitsi-meet': './index.js'
             },
-            output: Object.assign({}, config.output, {
+            output: { ...config.output,
                 library: 'JitsiMeetJS',
                 libraryTarget: 'umd',
-                path: path.join(process.cwd(), 'dist', 'umd')
-            })
-        }),
+                path: path.join(process.cwd(), 'dist', 'umd') } },
         {
             entry: {
                 worker: './modules/e2ee/Worker.js'