eslint 4.8.0

ESLint 4.8.0 discovers a lot of error related to formatting. While I
tried to fix as many of them as possible, a portion of them actually go
against our coding style. In such a case, I've disabled the indent rule
which effectively leaves it as it was before ESLint 4.8.0.

.eslintrc.js

         'id-blacklist': 0,
         'id-length': 0,
         'id-match': 0,
-        'indent': [ 'error', 4, { 'SwitchCase': 0 } ],
+        'indent': [
+            'error',
+            4,
+            {
+                'CallExpression': {
+                    arguments: 'off'
+                },
+                'FunctionDeclaration': {
+                    parameters: 2
+                },
+                'FunctionExpression': {
+                    parameters: 2
+                },
+                'MemberExpression': 'off',
+                'SwitchCase': 0
+            }
+        ],
         'key-spacing': 2,
         'keyword-spacing': 2,
         'linebreak-style': [ 'error', 'unix' ],

JitsiConference.js

         = new ParticipantConnectionStatusHandler(
             this.rtc,
             this,
-            {   // Both these options are not public API, leaving it here only
+            {
+                // Both these options are not public API, leaving it here only
                 // as an entry point through config for tuning up purposes.
                 // Default values should be adjusted as soon as optimal values
                 // are discovered.
             }
 
             return Promise.reject(new Error(
-                    'cannot add second video track to the conference'));
+                'cannot add second video track to the conference'));
 
         }
     }
  * @param {number} audioLevel the audio level
  * @param {TraceablePeerConnection} [tpc]
  */
-JitsiConference.prototype._fireAudioLevelChangeEvent
-= function(audioLevel, tpc) {
+JitsiConference.prototype._fireAudioLevelChangeEvent = function(
+        audioLevel,
+        tpc) {
     const activeTpc = this.getActivePeerConnection();
 
     // There will be no TraceablePeerConnection if audio levels do not come from
 
     newTrack.muteHandler = this._fireMuteChangeEvent.bind(this, newTrack);
     newTrack.audioLevelHandler = this._fireAudioLevelChangeEvent.bind(this);
-    newTrack.addEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
-                           newTrack.muteHandler);
-    newTrack.addEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
-                           newTrack.audioLevelHandler);
+    newTrack.addEventListener(
+        JitsiTrackEvents.TRACK_MUTE_CHANGED,
+        newTrack.muteHandler);
+    newTrack.addEventListener(
+        JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
+        newTrack.audioLevelHandler);
 
     newTrack._setConference(this);
 
 /**
  * Handles incoming call event.
  */
-JitsiConference.prototype.onIncomingCall
-= function(jingleSession, jingleOffer, now) {
+JitsiConference.prototype.onIncomingCall = function(
+        jingleSession,
+        jingleOffer,
+        now) {
     // Handle incoming P2P call
     if (jingleSession.isP2P) {
         const role = this.room.getMemberRole(jingleSession.peerjid);
  * @param {JingleSessionPC} jingleSession the session instance to be rejected.
  * @private
  */
-JitsiConference.prototype._rejectIncomingCallNonModerator
-= function(jingleSession) {
+JitsiConference.prototype._rejectIncomingCallNonModerator = function(
+        jingleSession) {
     this._rejectIncomingCall(
         jingleSession,
         {
  * error handler
  * @private
  */
-JitsiConference.prototype._rejectIncomingCall
-= function(jingleSession, options) {
+JitsiConference.prototype._rejectIncomingCall = function(
+        jingleSession,
+        options) {
     if (options && options.errorMsg) {
         GlobalOnErrorHandler.callErrorHandler(new Error(options.errorMsg));
     }
  * @param {String|null} reasonText human readable reason text which may provide
  * more details about why the call has been terminated.
  */
-JitsiConference.prototype.onCallEnded
-= function(jingleSession, reasonCondition, reasonText) {
+JitsiConference.prototype.onCallEnded = function(
+        jingleSession,
+        reasonCondition,
+        reasonText) {
     logger.info(
-        `Call ended: ${reasonCondition} - ${reasonText
-            } P2P ?${jingleSession.isP2P}`);
+        `Call ended: ${reasonCondition} - ${reasonText} P2P ?${
+            jingleSession.isP2P}`);
     if (jingleSession === this.jvbJingleSession) {
         this.wasStopped = true;
 
  */
 JitsiConference.prototype.myUserId = function() {
     return (
-        this.room
-            && this.room.myroomjid
-                ? Strophe.getResourceFromJid(this.room.myroomjid)
-                : null);
+        this.room && this.room.myroomjid
+            ? Strophe.getResourceFromJid(this.room.myroomjid)
+            : null);
 };
 
 JitsiConference.prototype.sendTones = function(tones, duration, pause) {
  * user feedback
  * @param detailedFeedback detailed feedback from the user. Not yet used
  */
-JitsiConference.prototype.sendFeedback
-= function(overallFeedback, detailedFeedback) {
+JitsiConference.prototype.sendFeedback = function(
+        overallFeedback,
+        detailedFeedback) {
     this.statistics.sendFeedback(overallFeedback, detailedFeedback);
 };
 
  * @param {jQuery} jingleOffer a jQuery selector pointing to 'jingle' IQ element
  * @private
  */
-JitsiConference.prototype._acceptP2PIncomingCall
-= function(jingleSession, jingleOffer) {
+JitsiConference.prototype._acceptP2PIncomingCall = function(
+        jingleSession,
+        jingleOffer) {
     this.isP2PConnectionInterrupted = false;
 
     // Accept the offer
  * @param {JingleSessionPC} jingleSession the session instance.
  * @private
  */
-JitsiConference.prototype._onIceConnectionEstablished
-= function(jingleSession) {
-
+JitsiConference.prototype._onIceConnectionEstablished = function(
+        jingleSession) {
     if (this.p2pJingleSession !== null) {
         // store the establishment time of the p2p session as a field of the
         // JitsiConference because the p2pJingleSession might get disposed (thus
  * @param {Array<JitsiRemoteTrack>} remoteTracks the tracks that will be removed
  * @private
  */
-JitsiConference.prototype._removeRemoteTracks
-= function(sessionNickname, remoteTracks) {
+JitsiConference.prototype._removeRemoteTracks = function(
+        sessionNickname,
+        remoteTracks) {
     for (const track of remoteTracks) {
         logger.info(`Removing remote ${sessionNickname} track: ${track}`);
         this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_REMOVED, track);
     this.isP2PConnectionInterrupted = false;
     this.p2pJingleSession
         = this.xmpp.connection.jingle.newP2PJingleSession(
-                this.room.myroomjid,
-                peerJid);
+            this.room.myroomjid,
+            peerJid);
     logger.info('Created new P2P JingleSession', this.room.myroomjid, peerJid);
 
     this.p2pJingleSession.initialize(true /* initiator */, this.room, this.rtc);
     const shouldBeInP2P = peerCount === 1;
 
     logger.debug(
-        `P2P? isModerator: ${isModerator
-            }, peerCount: ${peerCount} => ${shouldBeInP2P}`);
+        `P2P? isModerator: ${isModerator}, peerCount: ${peerCount} => ${
+            shouldBeInP2P}`);
 
     // Clear deferred "start P2P" task
     if (!shouldBeInP2P && this.deferredStartP2PTask) {
                 return;
             }
             logger.info(
-                `Will start P2P with: ${jid
-                    } after ${this.backToP2PDelay} seconds...`);
+                `Will start P2P with: ${jid} after ${
+                    this.backToP2PDelay} seconds...`);
             this.deferredStartP2PTask = setTimeout(
                 this._startP2PSession.bind(this, jid),
                 this.backToP2PDelay * 1000);
  * description that will be included in the session terminate message
  * @private
  */
-JitsiConference.prototype._stopP2PSession
-= function(reason, reasonDescription) {
+JitsiConference.prototype._stopP2PSession = function(
+        reason,
+        reasonDescription) {
     if (!this.p2pJingleSession) {
         logger.error('No P2P session to be stopped!');
 
  * this receiver is willing to receive.
  * @returns {void}
  */
-JitsiConference.prototype.setReceiverVideoConstraint
-= function(maxFrameHeight) {
+JitsiConference.prototype.setReceiverVideoConstraint = function(
+        maxFrameHeight) {
     this.rtc.setReceiverVideoConstraint(maxFrameHeight);
 };
 

JitsiMeetJS.js

                     Statistics.sendLog(JSON.stringify(logObject));
                     Statistics.analytics.sendEvent(
                         `getUserMedia.deviceNotFound.${
-                             error.gum.devices.join('.')}`);
+                            error.gum.devices.join('.')}`);
                 } else {
                     // Report gUM failed to the stats
                     Statistics.sendGetUserMediaFailed(error);

JitsiTrackError.js

                 this.message
                     = TRACK_ERROR_TO_MESSAGE_MAP[this.name]
                         + getResolutionFromFailedConstraint(
-                                constraintName,
-                                options);
+                            constraintName,
+                            options);
             } else {
                 this.name = JitsiTrackErrors.CONSTRAINT_FAILED;
                 this.message

doc/example/example.js

     room.on(
         JitsiMeetJS.events.conference.DISPLAY_NAME_CHANGED,
         (userID, displayName) => console.log(`${userID} - ${displayName}`));
-    room.on(JitsiMeetJS.events.conference.TRACK_AUDIO_LEVEL_CHANGED,
-      (userID, audioLevel) => {
-          console.log(`${userID} - ${audioLevel}`);
-      });
-    room.on(JitsiMeetJS.events.conference.RECORDER_STATE_CHANGED, () => {
-        console.log(`${room.isRecordingSupported()} - ${
-             room.getRecordingState()} - ${
-             room.getRecordingURL()}`);
-    });
-    room.on(JitsiMeetJS.events.conference.PHONE_NUMBER_CHANGED, () => {
-        console.log(
-            `${room.getPhoneNumber()} - ${
-             room.getPhonePin()}`);
-    });
+    room.on(
+        JitsiMeetJS.events.conference.TRACK_AUDIO_LEVEL_CHANGED,
+        (userID, audioLevel) => console.log(`${userID} - ${audioLevel}`));
+    room.on(
+        JitsiMeetJS.events.conference.RECORDER_STATE_CHANGED,
+        () =>
+            console.log(
+                `${room.isRecordingSupported()} - ${
+                    room.getRecordingState()} - ${
+                    room.getRecordingURL()}`));
+    room.on(
+        JitsiMeetJS.events.conference.PHONE_NUMBER_CHANGED,
+        () => console.log(`${room.getPhoneNumber()} - ${room.getPhonePin()}`));
     room.join();
 }
 
         localTracks[1].dispose();
         localTracks.pop();
     }
-    JitsiMeetJS.createLocalTracks(
-            { devices: isVideo ? [ 'video' ] : [ 'desktop' ] })
+    JitsiMeetJS.createLocalTracks({
+        devices: [ isVideo ? 'video' : 'desktop' ]
+    })
         .then(tracks => {
             localTracks.push(tracks[0]);
             localTracks[1].addEventListener(

karma.conf.js

 module.exports = function(config) {
     config.set({
 
-    // base path that will be used to resolve all patterns (eg. files, exclude)
+        // base path that will be used to resolve all patterns (eg. files,
+        // exclude)
         basePath: '',
 
-
-    // frameworks to use
-    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+        // frameworks to use
+        // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
         frameworks: [ 'jasmine' ],
 
-
-    // list of files / patterns to load in the browser
+        // list of files / patterns to load in the browser
         files: [
             './index.js',
             './modules/**/*.spec.js'
         ],
 
-
-    // list of files to exclude
+        // list of files to exclude
         exclude: [
         ],
 
-
-    // preprocess matching files before serving them to the browser
-    // available preprocessors:
-    //  https://npmjs.org/browse/keyword/karma-preprocessor
+        // preprocess matching files before serving them to the browser
+        // available preprocessors:
+        //  https://npmjs.org/browse/keyword/karma-preprocessor
         preprocessors: {
             './index.js': [ 'webpack' ],
             './**/*.spec.js': [ 'webpack' ]
         },
 
-
-    // test results reporter to use
-    // possible values: 'dots', 'progress'
-    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
+        // test results reporter to use
+        // possible values: 'dots', 'progress'
+        // available reporters: https://npmjs.org/browse/keyword/karma-reporter
         reporters: [ 'progress' ],
 
-
-    // web server port
+        // web server port
         port: 9876,
 
-
-    // enable / disable colors in the output (reporters and logs)
+        // enable / disable colors in the output (reporters and logs)
         colors: true,
 
-
-    // level of logging
-    // possible values: config.LOG_DISABLE || config.LOG_ERROR ||
-    //  config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+        // level of logging
+        // possible values: config.LOG_DISABLE || config.LOG_ERROR ||
+        //  config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
         logLevel: config.LOG_INFO,
 
-
-    // enable / disable watching file and executing tests whenever
-    // any file changes
+        // enable / disable watching file and executing tests whenever
+        // any file changes
         autoWatch: false,
 
-
-    // start these browsers
-    // available browser launchers:
-    // https://npmjs.org/browse/keyword/karma-launcher
+        // start these browsers
+        // available browser launchers:
+        // https://npmjs.org/browse/keyword/karma-launcher
         browsers: [ 'Chrome' ],
 
-
-    // Continuous Integration mode
-    // if true, Karma captures browsers, runs the tests and exits
+        // Continuous Integration mode
+        // if true, Karma captures browsers, runs the tests and exits
         singleRun: false,
 
         webpack: require('./webpack.config.js')

modules/RTC/JitsiLocalTrack.js

             promise = RTCUtils.obtainAudioAndVideoPermissions(streamOptions)
                 .then(streamsInfo => {
                     const mediaType = this.getType();
-                    const streamInfo = streamsInfo.find(
+                    const streamInfo
+                        = streamsInfo.find(
                             info => info.mediaType === mediaType);
 
                     if (streamInfo) {

modules/RTC/JitsiRemoteTrack.js

      * @constructor
      */
     constructor(
-        rtc,
-        conference,
-        ownerEndpointId,
-        stream,
-        track,
-        mediaType,
-        videoType,
-        ssrc,
-        muted,
-        isP2P) {
+            rtc,
+            conference,
+            ownerEndpointId,
+            stream,
+            track,
+            mediaType,
+            videoType,
+            ssrc,
+            muted,
+            isP2P) {
         super(
             conference,
             stream,
      * @return {string}
      */
     toString() {
-        return `RemoteTrack[${this.ownerEndpointId}, ${this.getType()
-                }, p2p: ${this.isP2P}]`;
+        return `RemoteTrack[${
+            this.ownerEndpointId}, ${
+            this.getType()}, p2p: ${
+            this.isP2P}]`;
     }
 }

modules/RTC/JitsiTrack.js

 
         return (
             Promise.all(
-                    this.containers.map(
-                        element =>
-                            element.setSinkId(audioOutputDeviceId)
-                                .catch(error => {
-                                    logger.warn(
-                                        'Failed to change audio output device'
-                                            + ' on element. Default or'
-                                            + ' previously set audio output'
-                                            + ' device will be used.',
-                                        element,
-                                        error);
-                                    throw error;
-                                })))
+                this.containers.map(
+                    element =>
+                        element.setSinkId(audioOutputDeviceId)
+                            .catch(error => {
+                                logger.warn(
+                                    'Failed to change audio output device on'
+                                        + ' element. Default or previously set'
+                                        + ' audio output device will be used.',
+                                    element,
+                                    error);
+                                throw error;
+                            }))
+            )
                 .then(() => {
                     this.emit(
                         JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED,

modules/RTC/LocalSdpMunger.js

             const shouldFakeSdp = muted || !isInPeerConnection;
 
             logger.debug(
-                `${this.tpc} ${videoTrack} muted: ${muted
-                    }, is in PeerConnection: ${isInPeerConnection
-                    } => should fake sdp ? : ${shouldFakeSdp}`);
+                `${this.tpc} ${videoTrack} muted: ${
+                    muted}, is in PeerConnection: ${
+                    isInPeerConnection} => should fake sdp ? : ${
+                    shouldFakeSdp}`);
 
             if (!shouldFakeSdp) {
                 continue; // eslint-disable-line no-continue

modules/RTC/RTCUIHelper.js

         if (!RTCBrowserType.isTemasysPluginUsed()) {
             return $(containerElement).find(videoElemName)[0];
         }
-        const matching = $(containerElement).find(
+        const matching
+            = $(containerElement).find(
                 ` ${videoElemName}>param[value="video"]`);
 
         if (matching.length) {
             if (matching.length > 1) {
                 logger.warn(
-                        'Container with more than one video elements: ',
-                        containerElement);
+                    'Container with more than one video elements: ',
+                    containerElement);
             }
 
             return matching.parent()[0];

modules/RTC/RTCUtils.js

  *
  */
 function initRawEnumerateDevicesWithCallback() {
-    rawEnumerateDevicesWithCallback = navigator.mediaDevices
-        && navigator.mediaDevices.enumerateDevices
-        ? function(callback) {
-            navigator.mediaDevices.enumerateDevices().then(
-                callback,
-                () => callback([]));
-        }
+    rawEnumerateDevicesWithCallback
+        = navigator.mediaDevices && navigator.mediaDevices.enumerateDevices
+            ? function(callback) {
+                navigator.mediaDevices.enumerateDevices().then(
+                    callback,
+                    () => callback([]));
+            }
 
-        // Safari:
-        // "ReferenceError: Can't find variable: MediaStreamTrack"
-        // when Temasys plugin is not installed yet, have to delay this call
-        // until WebRTC is ready.
-        : MediaStreamTrack && MediaStreamTrack.getSources
-        ? function(callback) {
-            MediaStreamTrack.getSources(
-                sources =>
-                    callback(sources.map(convertMediaStreamTrackSource)));
-        }
-        : undefined;
+            // Safari:
+            // "ReferenceError: Can't find variable: MediaStreamTrack" when
+            // Temasys plugin is not installed yet, have to delay this call
+            // until WebRTC is ready.
+            : MediaStreamTrack && MediaStreamTrack.getSources
+                ? function(callback) {
+                    MediaStreamTrack.getSources(
+                        sources =>
+                            callback(
+                                sources.map(convertMediaStreamTrackSource)));
+                }
+                : undefined;
 }
 
 // TODO: currently no browser supports 'devicechange' event even in nightly
 /**
  *
  * @param constraints
+ * @param isNewStyleConstraintsSupported
  * @param resolution
  */
 function setResolutionConstraints(
-    constraints, isNewStyleConstraintsSupported, resolution) {
+        constraints,
+        isNewStyleConstraintsSupported,
+        resolution) {
     if (Resolutions[resolution]) {
         if (isNewStyleConstraintsSupported) {
             constraints.video.width = {
         return true;
     }
 
+    /* eslint-disable newline-per-chained-call */
+
     return (
-        newDevices
-                .map(mediaDeviceInfoToJSON)
-                .sort()
-                .join('')
+        newDevices.map(mediaDeviceInfoToJSON).sort().join('')
             !== currentlyAvailableMediaDevices
-                .map(mediaDeviceInfoToJSON)
-                .sort()
-                .join(''));
+                .map(mediaDeviceInfoToJSON).sort().join(''));
+
+    /* eslint-enable newline-per-chained-call */
 
     /**
      *
                 }
             }
         } else {
-          // On other types of browser (e.g. Firefox) we choose (namely,
-          // obtainAudioAndVideoPermissions) to call getUserMedia per device
-          // (type).
+            // On other types of browser (e.g. Firefox) we choose (namely,
+            // obtainAudioAndVideoPermissions) to call getUserMedia per device
+            // (type).
             audioStream = streams.audio;
             videoStream = streams.video;
         }
                     = wrapGetUserMedia(
                         navigator.mediaDevices.getUserMedia.bind(
                             navigator.mediaDevices),
-                            true);
+                        true);
                 this.enumerateDevices = rawEnumerateDevicesWithCallback;
                 this.attachMediaStream
                     = wrapAttachMediaStream((element, stream) => {
 
             eventEmitter.addListener(RTCEvents.RTC_READY, listener);
 
-                // We have no failed event, so... it either resolves or nothing
-                // happens
+            // We have no failed event, so... it either resolves or nothing
+            // happens.
         });
 
     }
                         reason: err
                     });
 
-                    logger.warn('Failed to set audio output device for the '
-                        + 'element. Default audio output device will be used '
-                        + 'instead',
-                        element, err);
+                    logger.warn(
+                        'Failed to set audio output device for the element.'
+                            + ' Default audio output device will be used'
+                            + ' instead',
+                        element,
+                        err);
                 });
         }
 

modules/RTC/ScreenObtainer.js

             chromeExtInstalled = installed;
             chromeExtUpdateRequired = updateRequired;
             logger.info(
-                `Chrome extension installed: ${chromeExtInstalled
-                    } updateRequired: ${chromeExtUpdateRequired}`);
+                `Chrome extension installed: ${
+                    chromeExtInstalled} updateRequired: ${
+                    chromeExtUpdateRequired}`);
             resolve();
         }, options);
     });
     // "chrome://EXT_ID/content/DOMAIN.png"
     // Where EXT_ID is the ID of the extension with "@" replaced by ".", and
     // DOMAIN is a domain whitelisted by the extension.
-    const src
-        = `chrome://${options.desktopSharingFirefoxExtId.replace('@', '.')
-            }/content/${document.location.hostname}.png`;
+    const extId = options.desktopSharingFirefoxExtId.replace('@', '.');
+    const domain = document.location.hostname;
+    const src = `chrome://${extId}/content/${domain}.png`;
 
     img.setAttribute('src', src);
 }

modules/RTC/TraceablePeerConnection.js

  * connection.
  * @private
  */
-TraceablePeerConnection.prototype._getDesiredMediaDirection
-= function(mediaType) {
+TraceablePeerConnection.prototype._getDesiredMediaDirection = function(
+        mediaType) {
     let mediaTransferActive = true;
 
     if (mediaType === MediaType.AUDIO) {
  * @param {VideoType} videoType the new value
  * @private
  */
-TraceablePeerConnection.prototype._peerVideoTypeChanged
-= function(endpointId, videoType) {
+TraceablePeerConnection.prototype._peerVideoTypeChanged = function(
+        endpointId,
+        videoType) {
     // Check if endpointId has a value to avoid action on random track
     if (!endpointId) {
         logger.error(`No endpointID on peerVideoTypeChanged ${this}`);
  * @param {boolean} isMuted the new mute state
  * @private
  */
-TraceablePeerConnection.prototype._peerMutedChanged
-= function(endpointId, mediaType, isMuted) {
+TraceablePeerConnection.prototype._peerMutedChanged = function(
+        endpointId,
+        mediaType,
+        isMuted) {
     // Check if endpointId is a value to avoid doing action on all remote tracks
     if (!endpointId) {
         logger.error('On peerMuteChanged - no endpoint ID');
  * by their media type if this argument is specified.
  * @return {Array<JitsiRemoteTrack>}
  */
-TraceablePeerConnection.prototype.getRemoteTracks
-= function(endpointId, mediaType) {
+TraceablePeerConnection.prototype.getRemoteTracks = function(
+        endpointId,
+        mediaType) {
     const remoteTracks = [];
     const endpoints
         = endpointId ? [ endpointId ] : this.remoteTracks.keys();
     if (!mediaLines.length) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error(
-                `No media lines for type ${mediaType
-                     } found in remote SDP for remote track: ${streamId}`));
+                `No media lines for type ${
+                    mediaType} found in remote SDP for remote track: ${
+                    streamId}`));
 
         // Abort
         return;
     if (!ssrcLines.length) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error(
-                `No SSRC lines for streamId ${streamId
-                     } for remote track, media type: ${mediaType}`));
+                `No SSRC lines for streamId ${
+                    streamId} for remote track, media type: ${mediaType}`));
 
         // Abort
         return;
     if (isNaN(trackSsrc) || trackSsrc < 0) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error(
-                `Invalid SSRC: ${ssrcStr
-                    } for remote track, msid: ${streamId
-                    } media type: ${mediaType}`));
+                `Invalid SSRC: ${ssrcStr} for remote track, msid: ${
+                    streamId} media type: ${mediaType}`));
 
         // Abort
         return;
     } else if (!ownerEndpointId) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error(
-                `No SSRC owner known for: ${trackSsrc
-                     } for remote track, msid: ${streamId
-                     } media type: ${mediaType}`));
+                `No SSRC owner known for: ${
+                    trackSsrc} for remote track, msid: ${
+                    streamId} media type: ${mediaType}`));
 
         // Abort
         return;
  * @param {number} ssrc the track's main SSRC number
  * @param {boolean} muted the initial muted status
  */
-TraceablePeerConnection.prototype._createRemoteTrack
-= function(ownerEndpointId, stream, track, mediaType, videoType, ssrc, muted) {
+TraceablePeerConnection.prototype._createRemoteTrack = function(
+        ownerEndpointId,
+        stream,
+        track,
+        mediaType,
+        videoType,
+        ssrc,
+        muted) {
     const remoteTrack
         = new JitsiRemoteTrack(
             this.rtc, this.rtc.conference,
  * @param {MediaStreamTrack} track the WebRTC MediaStreamTrack which has been
  * removed from the PeerConnection.
  */
-TraceablePeerConnection.prototype._remoteTrackRemoved
-= function(stream, track) {
+TraceablePeerConnection.prototype._remoteTrackRemoved = function(
+        stream,
+        track) {
     const streamId = RTC.getStreamID(stream);
     const trackId = track && RTC.getTrackID(track);
 
  * <tt>undefined</tt> if not found.
  * @private
  */
-TraceablePeerConnection.prototype._getRemoteTrackById
-= function(streamId, trackId) {
+TraceablePeerConnection.prototype._getRemoteTrackById = function(
+        streamId,
+        trackId) {
     // .find will break the loop once the first match is found
     for (const endpointTrackMap of this.remoteTracks.values()) {
         for (const mediaTrack of endpointTrackMap.values()) {
     }
 
     logger.debug(
-        `${this} removed remote tracks for ${owner
-            } count: ${removedTracks.length}`);
+        `${this} removed remote tracks for ${owner} count: ${
+            removedTracks.length}`);
 
     return removedTracks;
 };
  * <tt>undefined</tt> if no track matching given stream and track ids was
  * found.
  */
-TraceablePeerConnection.prototype._removeRemoteTrackById
-= function(streamId, trackId) {
+TraceablePeerConnection.prototype._removeRemoteTrackById = function(
+        streamId,
+        trackId) {
     const toBeRemoved = this._getRemoteTrackById(streamId, trackId);
 
     if (toBeRemoved) {
                     && typeof group.ssrcs !== 'undefined') {
                     // Parse SSRCs and store as numbers
                     const groupSSRCs
-                        = group.ssrcs.split(' ')
-                                     .map(ssrcStr => parseInt(ssrcStr, 10));
+                        = group.ssrcs.split(' ').map(
+                            ssrcStr => parseInt(ssrcStr, 10));
                     const primarySSRC = groupSSRCs[0];
 
                     // Note that group.semantics is already present
  * <tt>false</tt> otherwise.
  * @private
  */
-TraceablePeerConnection.prototype._assertTrackBelongs
-= function(methodName, localTrack) {
+TraceablePeerConnection.prototype._assertTrackBelongs = function(
+        methodName,
+        localTrack) {
     const doesBelong = this.localTracks.has(localTrack.rtcId);
 
     if (!doesBelong) {
  * Remove stream handling for firefox
  * @param stream: webrtc media stream
  */
-TraceablePeerConnection.prototype._handleFirefoxRemoveStream
-= function(stream) {
+TraceablePeerConnection.prototype._handleFirefoxRemoveStream = function(
+        stream) {
     if (!stream) {
         // There is nothing to be changed
         return;
  * the local description.
  * @private
  */
-TraceablePeerConnection.prototype._ensureSimulcastGroupIsLast
-= function(localSdp) {
+TraceablePeerConnection.prototype._ensureSimulcastGroupIsLast = function(
+        localSdp) {
     let sdpStr = localSdp.sdp;
 
     const videoStartIndex = sdpStr.indexOf('m=video');
  * the local description.
  * @private
  */
-TraceablePeerConnection.prototype._adjustLocalMediaDirection
-= function(localDescription) {
+TraceablePeerConnection.prototype._adjustLocalMediaDirection = function(
+        localDescription) {
     const transformer = new SdpTransformWrap(localDescription.sdp);
     let modifiedDirection = false;
     const audioMedia = transformer.selectMedia('audio');
     }
 };
 
-TraceablePeerConnection.prototype.setLocalDescription
-= function(description, successCallback, failureCallback) {
+TraceablePeerConnection.prototype.setLocalDescription = function(
+        description,
+        successCallback,
+        failureCallback) {
     let localSdp = description;
 
     this.trace('setLocalDescription::preTransform', dumpSDP(localSdp));
         return desc;
     };
 
-TraceablePeerConnection.prototype.setRemoteDescription
-= function(description, successCallback, failureCallback) {
+TraceablePeerConnection.prototype.setRemoteDescription = function(
+        description,
+        successCallback,
+        failureCallback) {
     this.trace('setRemoteDescription::preTransform', dumpSDP(description));
 
     // TODO the focus should squeze or explode the remote simulcast
     if (RTCBrowserType.usesUnifiedPlan()) {
         description.sdp = this.rtxModifier.stripRtx(description.sdp);
         this.trace(
-                'setRemoteDescription::postTransform (stripRtx)',
-                dumpSDP(description));
+            'setRemoteDescription::postTransform (stripRtx)',
+            dumpSDP(description));
 
         // eslint-disable-next-line no-param-reassign
         description = this.interop.toUnifiedPlan(description);
         this.trace(
-                'setRemoteDescription::postTransform (Plan A)',
-                dumpSDP(description));
+            'setRemoteDescription::postTransform (Plan A)',
+            dumpSDP(description));
 
         if (this.isSimulcastOn()) {
             // eslint-disable-next-line no-param-reassign
             description = this._insertUnifiedPlanSimulcastReceive(description);
-            this.trace('setRemoteDescription::postTransform (sim receive)',
+            this.trace(
+                'setRemoteDescription::postTransform (sim receive)',
                 dumpSDP(description));
         }
     } else {
     }
 };
 
-TraceablePeerConnection.prototype.createAnswer
-= function(successCallback, failureCallback, constraints) {
-    if (RTCBrowserType.supportsRtpSender()
-            && this.isSimulcastOn()) {
+TraceablePeerConnection.prototype.createAnswer = function(
+        successCallback,
+        failureCallback,
+        constraints) {
+    if (RTCBrowserType.supportsRtpSender() && this.isSimulcastOn()) {
         const videoSender
             = this.peerconnection.getSenders().find(sender =>
                 sender.track.kind === 'video');
         false /* answer */, successCallback, failureCallback, constraints);
 };
 
-TraceablePeerConnection.prototype.createOffer
-= function(successCallback, failureCallback, constraints) {
+TraceablePeerConnection.prototype.createOffer = function(
+        successCallback,
+        failureCallback,
+        constraints) {
     this._createOfferOrAnswer(
         true /* offer */, successCallback, failureCallback, constraints);
 };
 
 /* eslint-disable max-params */
 
-TraceablePeerConnection.prototype._createOfferOrAnswer
-= function(isOffer, successCallback, failureCallback, constraints) {
+TraceablePeerConnection.prototype._createOfferOrAnswer = function(
+        isOffer,
+        successCallback,
+        failureCallback,
+        constraints) {
     const logName = isOffer ? 'Offer' : 'Answer';
 
     this.trace(`create${logName}`, JSON.stringify(constraints, null, ' '));
     }
 };
 
-TraceablePeerConnection.prototype.addIceCandidate
-= function(candidate, successCallback, failureCallback) {
+TraceablePeerConnection.prototype.addIceCandidate = function(
+        candidate,
+        successCallback,
+        failureCallback) {
     // var self = this;
     this.trace('addIceCandidate', JSON.stringify(candidate, null, ' '));
     this.peerconnection.addIceCandidate(

modules/connectivity/ConnectionQuality.js

      * @param data the statistics received
      */
     _updateRemoteStats(id, data) {
-            // Use only the fields we need
+        // Use only the fields we need
         this._remoteStats[id] = {
             bitrate: data.bitrate,
             packetLoss: data.packetLoss,
         };
 
         this.eventEmitter.emit(
-                ConnectionQualityEvents.REMOTE_STATS_UPDATED,
-                id,
-                this._remoteStats[id]);
+            ConnectionQualityEvents.REMOTE_STATS_UPDATED,
+            id,
+            this._remoteStats[id]);
     }
 
     /**

modules/connectivity/ParticipantConnectionStatus.js

      * @private
      */
     static _getNewStateForJvbMode(
-        isConnectionActiveByJvb,
-        isInLastN,
-        isRestoringTimedout,
-        isVideoMuted,
-        isVideoTrackFrozen) {
-
+            isConnectionActiveByJvb,
+            isInLastN,
+            isRestoringTimedout,
+            isVideoMuted,
+            isVideoTrackFrozen) {
         if (!isConnectionActiveByJvb) {
             // when there is a connection problem signaled from jvb
             // it means no media was flowing for at least 15secs, so both audio
         }
 
         logger.debug(
-            `Figure out conn status for ${id}, is video muted: ${isVideoMuted
-                 } is active(jvb): ${isConnActiveByJvb
-                 } video track frozen: ${isVideoTrackFrozen
-                 } p2p mode: ${inP2PMode
-                 } is in last N: ${isInLastN
-                 } currentStatus => newStatus: 
-                    ${participant.getConnectionStatus()} => ${newState}`);
+            `Figure out conn status for ${id}, is video muted: ${
+                isVideoMuted} is active(jvb): ${
+                isConnActiveByJvb} video track frozen: ${
+                isVideoTrackFrozen} p2p mode: ${
+                inP2PMode} is in last N: ${
+                isInLastN} currentStatus => newStatus: ${
+                participant.getConnectionStatus()} => ${newState}`);
 
         this._changeConnectionStatus(participant, newState);
     }

modules/statistics/AvgRTPStatsReporter.js

             if (isLocal ? peerID === myID : peerID !== myID) {
                 const participant
                     = isLocal
-                    ? null : this._conference.getParticipantById(peerID);
+                        ? null
+                        : this._conference.getParticipantById(peerID);
                 const videosResolution = peerResolutions[peerID];
 
                 // Do not continue without participant for non local peerID
             if (videoTracks) {
                 ssrcs
                     = ssrcs.filter(
-                    ssrc => videoTracks.find(
-                        track => !track.isMuted()
-                            && track.getSSRC() === ssrc
-                            && track.videoType === videoType));
+                        ssrc => videoTracks.find(
+                            track =>
+                                !track.isMuted()
+                                    && track.getSSRC() === ssrc
+                                    && track.videoType === videoType));
             }
         } else {
             videoTracks = this._conference.getLocalTracks(MediaType.VIDEO);
             ssrcs
                 = ssrcs.filter(
-                ssrc => videoTracks.find(
-                    track => !track.isMuted()
-                        && tpc.getLocalSSRC(track) === ssrc
-                        && track.videoType === videoType));
+                    ssrc => videoTracks.find(
+                        track =>
+                            !track.isMuted()
+                                && tpc.getLocalSSRC(track) === ssrc
+                                && track.videoType === videoType));
         }
 
         let peerPixelsSum = 0;

modules/statistics/CallStats.js

         const originalReportError = theBackend.reportError;
 
         /* eslint-disable max-params */
-        theBackend.reportError
-        = function(pc, cs, type, ...args) {
+        theBackend.reportError = function(pc, cs, type, ...args) {
             // Logs from the logger are submitted on the applicationLog event
             // "type". Logging the arguments on the logger will create endless
             // loop, because it will put all the logs to the logger queue again.

modules/statistics/RTPStatsCollector.js

 
             if (!conferenceStatsTransport.some(
                     t =>
-                       t.ip === ip
-                       && t.type === type
-                       && t.localip === localip)) {
+                        t.ip === ip
+                            && t.type === type
+                            && t.localip === localip)) {
                 conferenceStatsTransport.push({
                     ip,
                     type,
 
     this.conferenceStats.packetLoss = {
         total:
-            calculatePacketLoss(lostPackets.download + lostPackets.upload,
-                    totalPackets.download + totalPackets.upload),
+            calculatePacketLoss(
+                lostPackets.download + lostPackets.upload,
+                totalPackets.download + totalPackets.upload),
         download:
             calculatePacketLoss(lostPackets.download, totalPackets.download),
         upload:

modules/statistics/SpeakerStats.spec.js

             }
 
             expect(speakerStats.getTotalDominantSpeakerTime())
-              .toBe(domaintSpeakerTime * domaintSpeakerEvents);
+                .toBe(domaintSpeakerTime * domaintSpeakerEvents);
         });
     });
 });

modules/statistics/statistics.js

 function loadCallStatsAPI(customScriptUrl) {
     if (!isCallstatsLoaded) {
         ScriptUtil.loadScript(
-                customScriptUrl ? customScriptUrl
-                    : 'https://api.callstats.io/static/callstats-ws.min.js',
-                /* async */ true,
-                /* prepend */ true);
+            customScriptUrl
+                || 'https://api.callstats.io/static/callstats-ws.min.js',
+            /* async */ true,
+            /* prepend */ true);
         isCallstatsLoaded = true;
     }
 
 
     try {
         const rtpStats
-            = new RTPStats(peerconnection,
-                    Statistics.audioLevelsInterval, 2000, this.eventEmitter);
+            = new RTPStats(
+                peerconnection,
+                Statistics.audioLevelsInterval,
+                2000,
+                this.eventEmitter);
 
         rtpStats.start(Statistics.audioLevelsEnabled);
         this.rtpStatsMap.set(peerconnection.id, rtpStats);

modules/transcription/audioRecorder.js

 /**
  * Possible audio formats MIME types
  */
-const AUDIO_WEBM = 'audio/webm';    // Supported in chrome
-const AUDIO_OGG = 'audio/ogg';     // Supported in firefox
+const AUDIO_WEBM = 'audio/webm'; // Supported in chrome
+const AUDIO_OGG = 'audio/ogg'; // Supported in firefox
 
 /**
  * A TrackRecorder object holds all the information needed for recording a
     const array = [];
 
     this.recorders.forEach(
-          recorder =>
-              array.push(
-                  new RecordingResult(
-                      new Blob(recorder.data, { type: this.fileType }),
-                      recorder.name,
-                      recorder.startTime)));
+        recorder =>
+            array.push(
+                new RecordingResult(
+                    new Blob(recorder.data, { type: this.fileType }),
+                    recorder.name,
+                    recorder.startTime)));
 
     return array;
 };

modules/transcription/transcriber.js

     if (this.state !== BEFORE_STATE) {
         throw new Error(
             `The transcription can only start when it's in the "${
-                 BEFORE_STATE}" state. It's currently in the "${
-                 this.state}" state`);
+                BEFORE_STATE}" state. It's currently in the "${
+                this.state}" state`);
     }
     this.state = RECORDING_STATE;
     this.audioRecorder.start();
     if (this.state !== RECORDING_STATE) {
         throw new Error(
             `The transcription can only stop when it's in the "${
-                 RECORDING_STATE}" state. It's currently in the "${
-                 this.state}" state`);
+                RECORDING_STATE}" state. It's currently in the "${
+                this.state}" state`);
     }
 
     // stop the recording
 Transcriber.prototype.merge = function() {
     console.log(
         `starting merge process!\n The length of the array: ${
-             this.results.length}`);
+            this.results.length}`);
     this.transcription = '';
 
     // the merging algorithm will look over all Word objects who are at pos 0 in
     if (this.state !== FINISHED_STATE) {
         throw new Error(
             `The transcription can only be retrieved when it's in the "${
-                 FINISHED_STATE}" state. It's currently in the "${
-                 this.state}" state`);
+                FINISHED_STATE}" state. It's currently in the "${
+                this.state}" state`);
     }
 
     return this.transcription;

modules/xmpp/Caps.js

                         .each(
                             (idx, el) => features.add(el.getAttribute('var')));
                     if (user) {
-                            // TODO: Maybe use the version + node + hash
-                            // as keys?
-                        this.versionToCapabilities[user.version]
-                                = features;
+                        // TODO: Maybe use the version + node + hash as keys?
+                        this.versionToCapabilities[user.version] = features;
                     }
                     resolve(features);
                 }, reject, timeout)
      * Generates the value for the "ver" attribute.
      */
     _generateVersion() {
-        const identities = this.disco._identities.sort(compareIdentities);
-        const features = this.disco._features.sort();
-
-        this.version = b64_sha1(
-            identities.reduce(
-                    (accumulatedValue, identity) =>
-                        `${IDENTITY_PROPERTIES.reduce(
-                                (tmp, key, idx) =>
-                                    tmp
-                                        + (idx === 0 ? '' : '/')
-                                        + identity[key],
-                                '')
-                             }<`,
-                    '')
-                + features.reduce((tmp, feature) => `${tmp + feature}<`, ''));
+        const identities
+          = this.disco._identities.sort(compareIdentities).reduce(
+              (accumulatedValue, identity) =>
+                  `${
+                      IDENTITY_PROPERTIES.reduce(
+                          (tmp, key, idx) =>
+                              tmp
+                                  + (idx === 0 ? '' : '/')
+                                  + identity[key],
+                          '')
+                  }<`,
+              '');
+        const features
+            = this.disco._features.sort().reduce(
+                (tmp, feature) => `${tmp + feature}<`, '');
+
+        this.version = b64_sha1(identities + features);
         this._notifyVersionChanged();
     }
 

modules/xmpp/ChatRoom.js

 /* global $, $pres, $iq, $msg, __filename, Strophe */
+
 import { getLogger } from 'jitsi-meet-logger';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import * as JitsiTranscriptionStatus from '../../JitsiTranscriptionStatus';
      *
      */
     discoRoomInfo() {
-      // https://xmpp.org/extensions/xep-0045.html#disco-roominfo
+        // https://xmpp.org/extensions/xep-0045.html#disco-roominfo
 
-        const getInfo = $iq({ type: 'get',
-            to: this.roomjid })
-        .c('query', { xmlns: Strophe.NS.DISCO_INFO });
+        const getInfo
+            = $iq({
+                type: 'get',
+                to: this.roomjid
+            })
+                .c('query', { xmlns: Strophe.NS.DISCO_INFO });
 
         this.connection.sendIQ(getInfo, result => {
             const locked
                 = $(result).find('>query>feature[var="muc_passwordprotected"]')
-                        .length
+                    .length
                     === 1;
 
             if (locked !== this.locked) {
             switch (node.tagName) {
             case 'nick':
                 if (!member.isFocus) {
-                    const displayName = this.xmpp.options.displayJids
-                            ? Strophe.getResourceFromJid(from) : member.nick;
+                    const displayName
+                        = this.xmpp.options.displayJids
+                            ? Strophe.getResourceFromJid(from)
+                            : member.nick;
 
                     if (displayName && displayName.length > 0) {
                         this.eventEmitter.emit(
         if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]'
             + '>destroy').length) {
             let reason;
-            const reasonSelect = $(pres).find(
+            const reasonSelect
+                = $(pres).find(
                     '>x[xmlns="http://jabber.org/protocol/muc#user"]'
-                    + '>destroy>reason');
+                        + '>destroy>reason');
 
             if (reasonSelect.length) {
                 reason = reasonSelect.text();
         // Status code 110 indicates that this notification is "self-presence".
         const isSelfPresence
             = $(pres)
-                    .find(
-                        '>x[xmlns="http://jabber.org/protocol/muc#user"]>'
-                            + 'status[code="110"]')
-                    .length
-                !== 0;
+                .find(
+                    '>x[xmlns="http://jabber.org/protocol/muc#user"]>'
+                        + 'status[code="110"]')
+                .length;
         const isKick
             = $(pres)
-                    .find(
-                        '>x[xmlns="http://jabber.org/protocol/muc#user"]'
-                            + '>status[code="307"]')
-                    .length
-                !== 0;
+                .find(
+                    '>x[xmlns="http://jabber.org/protocol/muc#user"]'
+                        + '>status[code="307"]')
+                .length;
         const membersKeys = Object.keys(this.members);
 
         if (!isSelfPresence) {
      */
     addAudioInfoToPresence(mute) {
         this.removeFromPresence('audiomuted');
-        this.addToPresence('audiomuted',
-            { attributes:
-            { 'xmlns': 'http://jitsi.org/jitmeet/audio' },
-                value: mute.toString() });
+        this.addToPresence(
+            'audiomuted',
+            {
+                attributes: { 'xmlns': 'http://jitsi.org/jitmeet/audio' },
+                value: mute.toString()
+            });
     }
 
     /**
      */
     addVideoInfoToPresence(mute) {
         this.removeFromPresence('videomuted');
-        this.addToPresence('videomuted',
-            { attributes:
-            { 'xmlns': 'http://jitsi.org/jitmeet/video' },
-                value: mute.toString() });
+        this.addToPresence(
+            'videomuted',
+            {
+                attributes: { 'xmlns': 'http://jitsi.org/jitmeet/video' },
+                value: mute.toString()
+            });
     }
 
     /**

modules/xmpp/JingleSessionPC.js

                         });
                     this.wasConnected = true;
                     this.room.eventEmitter.emit(
-                            XMPPEvents.CONNECTION_ESTABLISHED, this);
+                        XMPPEvents.CONNECTION_ESTABLISHED, this);
                 }
                 this.isreconnect = false;
                 break;
                 }
                 this.isreconnect = true;
 
-                    // Informs interested parties that the connection has been
-                    // interrupted.
+                // Informs interested parties that the connection has been
+                // interrupted.
                 if (this.wasstable) {
                     this.room.eventEmitter.emit(
                         XMPPEvents.CONNECTION_INTERRUPTED, this);
                 ice.xmlns = 'urn:xmpp:jingle:transports:ice-udp:1';
                 cand.c('content', {
                     creator: this.initiator === this.localJid
-                                    ? 'initiator' : 'responder',
+                        ? 'initiator' : 'responder',
                     name: cands[0].sdpMid ? cands[0].sdpMid : mline.media
                 }).c('transport', ice);
                 for (let i = 0; i < cands.length; i++) {
                                         + ` for ${owner}`);
                             } else {
                                 this.signalingLayer.setSSRCOwner(
-                                ssrc, Strophe.getResourceFromJid(owner));
+                                    ssrc,
+                                    Strophe.getResourceFromJid(owner));
                             }
                         }
                     });
                 }, error => {
                     logger.error(
                         `Error renegotiating after setting new remote ${
-                            (this.isInitiator ? 'answer: ' : 'offer: ')
-                            }${error}`, newRemoteSdp);
+                            this.isInitiator ? 'answer: ' : 'offer: '}${error}`,
+                        newRemoteSdp);
                     JingleSessionPC.onJingleFatalError(this, error);
                     finishedCallback(error);
                 });
                 to: this.peerjid,
                 type: 'set'
             })
-            .c('jingle', {
-                xmlns: 'urn:xmpp:jingle:1',
-                action: 'content-modify',
-                initiator: this.initiator,
-                sid: this.sid
-            })
-            .c('content', {
-                name: 'video',
-                senders: newSendersValue
-            });
+                .c('jingle', {
+                    xmlns: 'urn:xmpp:jingle:1',
+                    action: 'content-modify',
+                    initiator: this.initiator,
+                    sid: this.sid
+                })
+                .c('content', {
+                    name: 'video',
+                    senders: newSendersValue
+                });
 
         logger.info(
             `Sending content-modify, video senders: ${newSendersValue}`);
                     to: this.peerjid,
                     type: 'set'
                 })
-                .c('jingle', {
-                    xmlns: 'urn:xmpp:jingle:1',
-                    action: 'session-terminate',
-                    initiator: this.initiator,
-                    sid: this.sid
-                })
-                .c('reason')
-                .c((options && options.reason) || 'success');
+                    .c('jingle', {
+                        xmlns: 'urn:xmpp:jingle:1',
+                        action: 'session-terminate',
+                        initiator: this.initiator,
+                        sid: this.sid
+                    })
+                    .c('reason')
+                    .c((options && options.reason) || 'success');
 
             if (options && options.reasonDescription) {
                 sessionTerminate.up()
 
                     if (ssrcs.length) {
                         lines
-                            += `a=ssrc-group:${semantics} ${ssrcs.join(' ')
-                                }\r\n`;
+                            += `a=ssrc-group:${semantics} ${
+                                ssrcs.join(' ')}\r\n`;
                     }
                 });
 
 
                     if (ssrcs.length) {
                         lines
-                            += `a=ssrc-group:${semantics} ${ssrcs.join(' ')
-                                }\r\n`;
+                            += `a=ssrc-group:${semantics} ${
+                                ssrcs.join(' ')}\r\n`;
                     }
 
                     /* eslint-enable no-invalid-this */

modules/xmpp/RtxModifier.spec.js

 function numVideoSsrcs(parsedSdp) {
     const videoMLine = parsedSdp.media.find(m => m.type === 'video');
 
-
     return videoMLine.ssrcs
-    .map(ssrcInfo => ssrcInfo.id)
-    .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
-    .length;
+        .map(ssrcInfo => ssrcInfo.id)
+        .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
+        .length;
 }
 
 /**
     videoMLine.ssrcGroups = videoMLine.ssrcGroups || [];
 
     return videoMLine.ssrcGroups
-    .filter(g => g.semantics === groupSemantics);
+        .filter(g => g.semantics === groupSemantics);
 }
 
 describe('RtxModifier', () => {
                 this.primaryVideoSsrc = getPrimaryVideoSsrc(this.singleVideoSdp);
             });
             it('should add a single rtx ssrc', function() {
-          // Call rtxModifier.modifyRtxSsrcs with an sdp that contains a single video
-          //  ssrc.  The returned sdp should have an rtx ssrc and an fid group.
+                // Call rtxModifier.modifyRtxSsrcs with an sdp that contains a single video
+                //  ssrc.  The returned sdp should have an rtx ssrc and an fid group.
                 const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
                 const newSdp = transform.parse(newSdpStr);
                 const newPrimaryVideoSsrc = getPrimaryVideoSsrc(newSdp);
 
                 expect(newPrimaryVideoSsrc).toEqual(this.primaryVideoSsrc);
 
-          // Should now have an rtx ssrc as well
+                // Should now have an rtx ssrc as well
                 expect(numVideoSsrcs(newSdp)).toEqual(2);
 
-          // Should now have an FID group
+                // Should now have an FID group
                 const fidGroups = getVideoGroups(newSdp, 'FID');
 
                 expect(fidGroups.length).toEqual(1);
             });
 
             it('should re-use the same rtx ssrc for a primary ssrc it\'s seen before', function() {
-          // Have rtxModifier generate an rtx ssrc via modifyRtxSsrcs.  Then call it again
-          //  with the same primary ssrc in the sdp (but no rtx ssrc).  It should use
-          //  the same rtx ssrc as before.
+                // Have rtxModifier generate an rtx ssrc via modifyRtxSsrcs.  Then call it again
+                //  with the same primary ssrc in the sdp (but no rtx ssrc).  It should use
+                //  the same rtx ssrc as before.
                 let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
                 let newSdp = transform.parse(newSdpStr);
 
                 let fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
 
-          // Now pass the original sdp through again
+                // Now pass the original sdp through again
                 newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
                 fidGroup = getVideoGroups(newSdp, 'FID')[0];
             });
 
             it('should NOT re-use the same rtx ssrc for a primary ssrc it\'s seen before if the cache has been cleared', function() {
-          // Call modifyRtxSsrcs to generate an rtx ssrc
-          // Clear the rtxModifier cache
-          // Call modifyRtxSsrcs to generate an rtx ssrc again with the same primary ssrc
-          // --> We should get a different rtx ssrc
+                // Call modifyRtxSsrcs to generate an rtx ssrc
+                // Clear the rtxModifier cache
+                // Call modifyRtxSsrcs to generate an rtx ssrc again with the same primary ssrc
+                // --> We should get a different rtx ssrc
                 let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
                 let newSdp = transform.parse(newSdpStr);
 
 
                 this.rtxModifier.clearSsrcCache();
 
-          // Now pass the original sdp through again
+                // Now pass the original sdp through again
                 newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
                 fidGroup = getVideoGroups(newSdp, 'FID')[0];
             });
 
             it('should use the rtx ssrc from the cache when the cache has been manually set', function() {
-          // Manually set an rtx ssrc mapping in the cache
-          // Call modifyRtxSsrcs
-          // -->The rtx ssrc used should be the one we set
+                // Manually set an rtx ssrc mapping in the cache
+                // Call modifyRtxSsrcs
+                // -->The rtx ssrc used should be the one we set
                 const forcedRtxSsrc = 123456;
                 const ssrcCache = new Map();
 
             });
 
             it('should add rtx ssrcs for all of them', function() {
-          // Call rtxModifier.modifyRtxSsrcs with an sdp that contains multiple video
-          //  ssrcs.  The returned sdp should have an rtx ssrc and an fid group for all of them.
+                // Call rtxModifier.modifyRtxSsrcs with an sdp that contains multiple video
+                //  ssrcs.  The returned sdp should have an rtx ssrc and an fid group for all of them.
                 const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
                 const newSdp = transform.parse(newSdpStr);
                 const newPrimaryVideoSsrcs = getPrimaryVideoSsrcs(newSdp);
 
                 expect(newPrimaryVideoSsrcs).toEqual(this.primaryVideoSsrcs);
 
-          // Should now have rtx ssrcs as well
+                // Should now have rtx ssrcs as well
                 expect(numVideoSsrcs(newSdp)).toEqual(this.primaryVideoSsrcs.length * 2);
 
-          // Should now have FID groups
+                // Should now have FID groups
                 const fidGroups = getVideoGroups(newSdp, 'FID');
 
                 expect(fidGroups.length).toEqual(this.primaryVideoSsrcs.length);
             });
 
             it('should re-use the same rtx ssrcs for any primary ssrc it\'s seen before', function() {
-          // Have rtxModifier generate an rtx ssrc via modifyRtxSsrcs.  Then call it again
-          //  with the same primary ssrc in the sdp (but no rtx ssrc).  It should use
-          //  the same rtx ssrc as before.
+                // Have rtxModifier generate an rtx ssrc via modifyRtxSsrcs.  Then call it again
+                //  with the same primary ssrc in the sdp (but no rtx ssrc).  It should use
+                //  the same rtx ssrc as before.
                 let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
                 let newSdp = transform.parse(newSdpStr);
 
                 const rtxMapping = new Map();
                 let fidGroups = getVideoGroups(newSdp, 'FID');
 
-          // Save the first mapping that is made
+                // Save the first mapping that is made
 
                 fidGroups.forEach(fidGroup => {
                     const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
                     rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
                 });
 
-          // Now pass the original sdp through again and make sure we get the same mapping
+                // Now pass the original sdp through again and make sure we get the same mapping
                 newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
                 fidGroups = getVideoGroups(newSdp, 'FID');
             });
 
             it('should NOT re-use the same rtx ssrcs for any primary ssrc it\'s seen before if the cache has been cleared', function() {
-          // Call modifyRtxSsrcs to generate an rtx ssrc
-          // Clear the rtxModifier cache
-          // Call modifyRtxSsrcs to generate rtx ssrcs again with the same primary ssrcs
-          // --> We should get different rtx ssrcs
+                // Call modifyRtxSsrcs to generate an rtx ssrc
+                // Clear the rtxModifier cache
+                // Call modifyRtxSsrcs to generate rtx ssrcs again with the same primary ssrcs
+                // --> We should get different rtx ssrcs
                 let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
                 let newSdp = transform.parse(newSdpStr);
 
                 const rtxMapping = new Map();
                 let fidGroups = getVideoGroups(newSdp, 'FID');
 
-          // Save the first mapping that is made
+                // Save the first mapping that is made
 
                 fidGroups.forEach(fidGroup => {
                     const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
 
                 this.rtxModifier.clearSsrcCache();
 
-          // Now pass the original sdp through again and make sure we get the same mapping
+                // Now pass the original sdp through again and make sure we get the same mapping
                 newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
                 fidGroups = getVideoGroups(newSdp, 'FID');
             });
 
             it('should use the rtx ssrcs from the cache when the cache has been manually set', function() {
-          // Manually set an rtx ssrc mapping in the cache
-          // Call modifyRtxSsrcs
-          // -->The rtx ssrc used should be the one we set
+                // Manually set an rtx ssrc mapping in the cache
+                // Call modifyRtxSsrcs
+                // -->The rtx ssrc used should be the one we set
                 const rtxMapping = new Map();
 
                 this.primaryVideoSsrcs.forEach(ssrc => {

modules/xmpp/SDP.js

         tmp = SDPUtil.findLines(self.media[mediaindex], 'a=ssrc:');
         const mid
             = SDPUtil.parseMID(
-                SDPUtil.findLine(self.media[mediaindex],
-                'a=mid:'));
+                SDPUtil.findLine(self.media[mediaindex], 'a=mid:'));
         const media = {
             mediaindex,
             mid,
                 += $(this)
                     .find('parameter')
                     .map(function() {
-                        return (this.getAttribute('name')
-                                ? `${this.getAttribute('name')}=` : '')
-                            + this.getAttribute('value');
+                        const name = this.getAttribute('name');
+
+                        return (
+                            (name ? `${name}=` : '')
+                                + this.getAttribute('value'));
                     })
                     .get()
                     .join('; ');

modules/xmpp/SDPUtil.js

      */
     getUfrag(sdp) {
         const ufragLines
-            = sdp.split('\n').filter(
-                    line => line.startsWith('a=ice-ufrag:'));
+            = sdp.split('\n').filter(line => line.startsWith('a=ice-ufrag:'));
 
         if (ufragLines.length > 0) {
             return ufragLines[0].substr('a=ice-ufrag:'.length);

modules/xmpp/SdpTransformUtil.js

     }
 
     return mLine.ssrcs
-            .map(ssrcInfo => ssrcInfo.id)
-            .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
-            .length;
+        .map(ssrcInfo => ssrcInfo.id)
+        .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
+        .length;
 }
 
 /**
             return this.mLine.ssrcs[0].id;
         }
 
-            // Look for a SIM or FID group
+        // Look for a SIM or FID group
         if (this.mLine.ssrcGroups) {
             const simGroup = this.findGroup('SIM');
 
 
         this.mLine.ssrcGroups
             = this.mLine.ssrcGroups
-                  .filter(groupInfo => groupInfo.semantics !== semantics);
+                .filter(groupInfo => groupInfo.semantics !== semantics);
     }
 
     /**

modules/xmpp/moderator.js

     logger.info(`Authentication enabled: ${authenticationEnabled}`);
 
     this.externalAuthEnabled = $(resultIq).find(
-            '>conference>property'
+        '>conference>property'
             + '[name=\'externalAuth\'][value=\'true\']').length > 0;
 
     logger.info(
             errorMsg = errorTextNode.text();
         }
         this.eventEmitter.emit(
-                XMPPEvents.RESERVATION_ERROR, errorCode, errorMsg);
+            XMPPEvents.RESERVATION_ERROR,
+            errorCode,
+            errorMsg);
 
         return;
     }
 
     if (!invalidSession) {
         this.eventEmitter.emit(
-                XMPPEvents.FOCUS_DISCONNECTED, focusComponent, retrySec);
+            XMPPEvents.FOCUS_DISCONNECTED,
+            focusComponent,
+            retrySec);
     }
 
     // Reset response timeout
             },
             errorIq => reject({
                 error: $(errorIq).find('iq>error :first')
-                                 .prop('tagName'),
+                    .prop('tagName'),
                 message: $(errorIq).find('iq>error>text')
-                                   .text()
+                    .text()
             })
         );
     });

modules/xmpp/recording.js

-  /* global $, $iq */
+/* global $, $iq */
 
 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
  * @param {Element|Object} errorIqNode - Either DOM element or the structure
  * from ChatRoom packet2JSON.
  * @return {{
- *      code: string,
- *      type: string,
- *      message: string
+ *     code: string,
+ *     type: string,
+ *     message: string
  * }}
  */
 function getJibriErrorDetails(errorIqNode) {
         })
             .c('jibri', {
                 'xmlns': 'http://jitsi.org/protocol/jibri',
-                'action': state === Recording.status.ON
+                'action':
+                    state === Recording.status.ON
                         ? Recording.action.START
                         : Recording.action.STOP,
-                'recording_mode': this.type === Recording.types.JIBRI_FILE
+                'recording_mode':
+                    this.type === Recording.types.JIBRI_FILE
                         ? 'file'
                         : 'stream',
-                'streamid': this.type === Recording.types.JIBRI
+                'streamid':
+                    this.type === Recording.types.JIBRI
                         ? options.streamId
                         : undefined
             })
     logger.log(`Set jibri recording: ${state}`, iq.nodeTree);
     logger.log(iq.nodeTree);
     this.connection.sendIQ(
-    iq,
-    result => {
-        logger.log('Result', result);
-
-        const jibri = $(result).find('jibri');
-
-        callback(jibri.attr('state'), jibri.attr('url'));
-    },
-    error => {
-        logger.log(
-            'Failed to start recording, error: ', getJibriErrorDetails(error));
-        errCallback(error);
-    });
+        iq,
+        result => {
+            logger.log('Result', result);
+
+            const jibri = $(result).find('jibri');
+
+            callback(jibri.attr('state'), jibri.attr('url'));
+        },
+        error => {
+            logger.log(
+                'Failed to start recording, error: ',
+                getJibriErrorDetails(error));
+            errCallback(error);
+        });
 };
 
 /* eslint-enable max-params */
             errCallback(new Error('Invalid state!'));
         }
 
-        const iq = $iq({ to: this.jirecon,
-            type: 'set' })
-        .c('recording', { xmlns: 'http://jitsi.org/protocol/jirecon',
-            action: state === Recording.status.ON
-                ? Recording.action.START
-                : Recording.action.STOP,
-            mucjid: this.roomjid });
+        const iq
+            = $iq({
+                to: this.jirecon,
+                type: 'set'
+            })
+                .c('recording', { xmlns: 'http://jitsi.org/protocol/jirecon',
+                    action: state === Recording.status.ON
+                        ? Recording.action.START
+                        : Recording.action.STOP,
+                    mucjid: this.roomjid });
 
         if (state === Recording.status.OFF) {
             iq.attrs({ rid: this.jireconRid });
         const self = this;
 
         this.connection.sendIQ(
-        iq,
-        result => {
-            // TODO wait for an IQ with the real status, since this is
-            // provisional?
-            // eslint-disable-next-line newline-per-chained-call
-            self.jireconRid = $(result).find('recording').attr('rid');
-            logger.log(
-                `Recording ${
-                    state === Recording.status.ON ? 'started' : 'stopped'
-                    }(jirecon)${result}`);
-            self.state = state;
-            if (state === Recording.status.OFF) {
-                self.jireconRid = null;
-            }
+            iq,
+            result => {
+                // TODO wait for an IQ with the real status, since this is
+                // provisional?
+                // eslint-disable-next-line newline-per-chained-call
+                self.jireconRid = $(result).find('recording').attr('rid');
 
-            callback(state);
-        },
-        error => {
-            logger.log('Failed to start recording, error: ', error);
-            errCallback(error);
-        });
+                const stateStr
+                    = state === Recording.status.ON ? 'started' : 'stopped';
+
+                logger.log(`Recording ${stateStr}(jirecon)${result}`);
+
+                self.state = state;
+                if (state === Recording.status.OFF) {
+                    self.jireconRid = null;
+                }
+
+                callback(state);
+            },
+            error => {
+                logger.log('Failed to start recording, error: ', error);
+                errCallback(error);
+            });
     };
 
 /* eslint-disable max-params */
  * @param statusChangeHandler {function} receives the new status as argument.
  */
 Recording.prototype.toggleRecording = function(
-    options = { },
-    statusChangeHandler) {
+        options = { },
+        statusChangeHandler) {
     const oldState = this.state;
 
     // If the recorder is currently unavailable we throw an error.
     if (oldState === Recording.status.UNAVAILABLE
         || oldState === Recording.status.FAILED) {
-        statusChangeHandler(Recording.status.FAILED,
-                            JitsiRecorderErrors.RECORDER_UNAVAILABLE);
+        statusChangeHandler(
+            Recording.status.FAILED,
+            JitsiRecorderErrors.RECORDER_UNAVAILABLE);
     } else if (oldState === Recording.status.BUSY) {
-        statusChangeHandler(Recording.status.BUSY,
-                            JitsiRecorderErrors.RECORDER_BUSY);
+        statusChangeHandler(
+            Recording.status.BUSY,
+            JitsiRecorderErrors.RECORDER_BUSY);
     }
 
     // If we're about to turn ON the recording we need either a streamId or
     // an authentication token depending on the recording type. If we don't
     // have any of those we throw an error.
     if ((oldState === Recording.status.OFF
-        || oldState === Recording.status.AVAILABLE)
-        && ((!options.token && this.type === Recording.types.COLIBRI)
-        || (!options.streamId && this.type === Recording.types.JIBRI))) {
-        statusChangeHandler(Recording.status.FAILED,
-                            JitsiRecorderErrors.NO_TOKEN);
+                || oldState === Recording.status.AVAILABLE)
+            && ((!options.token && this.type === Recording.types.COLIBRI)
+                || (!options.streamId
+                    && this.type === Recording.types.JIBRI))) {
+        statusChangeHandler(
+            Recording.status.FAILED,
+            JitsiRecorderErrors.NO_TOKEN);
         logger.error('No token passed!');
 
         return;
     }
 
-    const newState = oldState === Recording.status.AVAILABLE
-                    || oldState === Recording.status.OFF
-                    ? Recording.status.ON
-                    : Recording.status.OFF;
+    const newState
+        = oldState === Recording.status.AVAILABLE
+                || oldState === Recording.status.OFF
+            ? Recording.status.ON
+            : Recording.status.OFF;
 
     const self = this;
 

modules/xmpp/strophe.jingle.js

                 const audioMuted = startMuted.attr('audio');
                 const videoMuted = startMuted.attr('video');
 
-                this.eventEmitter.emit(XMPPEvents.START_MUTED_FROM_FOCUS,
-                        audioMuted === 'true', videoMuted === 'true');
+                this.eventEmitter.emit(
+                    XMPPEvents.START_MUTED_FROM_FOCUS,
+                    audioMuted === 'true',
+                    videoMuted === 'true');
             }
 
             // FIXME that should work most of the time, but we'd have to
             logger.info(
                 `Marking session from ${fromJid
                 } as ${isP2P ? '' : '*not*'} P2P`);
-            sess = new JingleSessionPC(
-                        $(iq).find('jingle').attr('sid'),
-                        $(iq).attr('to'),
-                        fromJid,
-                        this.connection,
-                        this.mediaConstraints,
-                        isP2P ? this.p2pIceConfig : this.jvbIceConfig,
-                        isP2P /* P2P */,
-                        false /* initiator */,
-                        this.xmpp.options);
+            sess
+                = new JingleSessionPC(
+                    $(iq).find('jingle').attr('sid'),
+                    $(iq).attr('to'),
+                    fromJid,
+                    this.connection,
+                    this.mediaConstraints,
+                    isP2P ? this.p2pIceConfig : this.jvbIceConfig,
+                    isP2P,
+                    /* initiator */ false,
+                    this.xmpp.options);
 
             this.sessions[sess.sid] = sess;
 
             this.eventEmitter.emit(XMPPEvents.CALL_INCOMING,
-                    sess, $(iq).find('>jingle'), now);
+                sess, $(iq).find('>jingle'), now);
             Statistics.analytics.sendEvent(
-                    'xmpp.session-initiate', { value: now });
+                'xmpp.session-initiate', { value: now });
             break;
         }
         case 'session-accept': {
         case 'transport-replace':
             logger.info('(TIME) Start transport replace', now);
             Statistics.analytics.sendEvent(
-                    'xmpp.transport-replace.start', { value: now });
+                'xmpp.transport-replace.start',
+                { value: now });
 
             sess.replaceTransport($(iq).find('>jingle'), () => {
                 const successTime = window.performance.now();
 
-                logger.info(
-                        '(TIME) Transport replace success!', successTime);
+                logger.info('(TIME) Transport replace success!', successTime);
                 Statistics.analytics.sendEvent(
-                        'xmpp.transport-replace.success',
-                        { value: successTime });
+                    'xmpp.transport-replace.success',
+                    { value: successTime });
             }, error => {
                 GlobalOnErrorHandler.callErrorHandler(error);
                 logger.error('Transport replace failed', error);
             logger.warn('jingle action not implemented', action);
             ack.attrs({ type: 'error' });
             ack.c('error', { type: 'cancel' })
-                    .c('bad-request',
-                        { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' })
-                    .up();
+                .c('bad-request',
+                    { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' })
+                .up();
             break;
         }
         this.connection.send(ack);
     newP2PJingleSession(me, peer) {
         const sess
             = new JingleSessionPC(
-                    RandomUtil.randomHexString(12),
-                    me,
-                    peer,
-                    this.connection,
-                    this.mediaConstraints,
-                    this.p2pIceConfig,
-                    true /* P2P */,
-                    true /* initiator */,
-                    this.xmpp.options);
+                RandomUtil.randomHexString(12),
+                me,
+                peer,
+                this.connection,
+                this.mediaConstraints,
+                this.p2pIceConfig,
+                /* P2P */ true,
+                /* initiator */ true,
+                this.xmpp.options);
 
         this.sessions[sess.sid] = sess;
 
                         // ?id=1508
 
                         if (username) {
-                            if (navigator.userAgent.match(
-                                    /Chrom(e|ium)\/([0-9]+)\./)
-                                    && parseInt(
-                                        navigator.userAgent.match(
-                                            /Chrom(e|ium)\/([0-9]+)\./)[2],
-                                            10) < 28) {
+                            const match
+                                = navigator.userAgent.match(
+                                    /Chrom(e|ium)\/([0-9]+)\./);
+
+                            if (match && parseInt(match[2], 10) < 28) {
                                 dict.url += `${username}@`;
                             } else {
-                                    // only works in M28
+                                // only works in M28
                                 dict.username = username;
                             }
                         }

modules/xmpp/strophe.util.js

         /* eslint-disable no-case-declarations */
         switch (level) {
         case Strophe.LogLevel.DEBUG:
-                // The log message which reports successful status is logged
-                // on Strophe's DEBUG level
+            // The log message which reports successful status is logged on
+            // Strophe's DEBUG level.
             if (lastErrorStatus !== -1
-                        && resetLastErrorStatusRegExpr.test(msg)) {
+                    && resetLastErrorStatusRegExpr.test(msg)) {
                 logger.debug('Reset lastErrorStatus');
                 lastErrorStatus = -1;
             }

modules/xmpp/xmpp.js

                 this.authenticatedUser = true;
             }
             if (this.connection && this.connection.connected
-                && Strophe.getResourceFromJid(this.connection.jid)) {
+                    && Strophe.getResourceFromJid(this.connection.jid)) {
                 // .connected is true while connecting?
-    //                this.connection.send($pres());
+                // this.connection.send($pres());
                 this.eventEmitter.emit(
-                        JitsiConnectionEvents.CONNECTION_ESTABLISHED,
-                        Strophe.getResourceFromJid(this.connection.jid));
+                    JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+                    Strophe.getResourceFromJid(this.connection.jid));
             }
         } else if (status === Strophe.Status.CONNFAIL) {
             if (msg === 'x-strophe-bad-non-anon-jid') {

package.json

   },
   "devDependencies": {
     "babel-core": "6.26.0",
-    "babel-eslint": "7.2.3",
+    "babel-eslint": "8.0.1",
     "babel-loader": "7.1.2",
     "babel-preset-es2015": "6.24.1",
     "babel-preset-stage-1": "6.24.1",
-    "eslint": "3.19.0",
-    "eslint-plugin-flowtype": "2.30.4",
+    "eslint": "4.8.0",
+    "eslint-plugin-flowtype": "2.37.0",
     "eslint-plugin-import": "2.7.0",
     "flow-bin": "0.38.0",
     "jasmine-core": "2.5.2",

webpack.config.js

                 flags: 'g',
                 replace:
                     child_process.execSync( // eslint-disable-line camelcase
-                            `${__dirname}/get-version.sh`)
+                        `${__dirname}/get-version.sh`)
 
                         // The type of the return value of
                         // child_process.execSync is either Buffer or String.
                         .toString()
 
-                            // Shells may automatically append CR and/or LF
-                            // characters to the output.
-                            .trim(),
+                        // Shells may automatically append CR and/or LF
+                        // characters to the output.
+                        .trim(),
                 search: '{#COMMIT_HASH#}'
             },
             test: `${__dirname}/JitsiMeetJS.js`