[eslint] newline-after-var, newline-before-return, newline-per-chained-call

.eslintrc.js

         'multiline-ternary': 0,
         'new-cap': 2,
         'new-parens': 2,
+        'newline-after-var': 2,
+        'newline-before-return': 2,
+        'newline-per-chained-call': 2,
         'no-array-constructor': 2,
         'no-bitwise': 2,
         'no-continue': 2,

JitsiConference.js

         const errmsg
             = 'Invalid conference name (no conference name passed or it '
                 + 'contains invalid characters like capital letters)!';
+
         logger.error(errmsg);
         throw new Error(errmsg);
     }
     // leave the conference
     if (this.room) {
         const room = this.room;
+
         this.room = null;
+
         return room.leave().catch(() => {
             // remove all participants because currently the conference won't
             // be usable anyway. This is done on success automatically by the
     return new Promise((resolve, reject) => {
         if (!this.isExternalAuthEnabled()) {
             reject();
+
             return;
         }
         if (urlForPopup) {
  */
 JitsiConference.prototype.getLocalTracks = function(mediaType) {
     let tracks = [];
+
     if (this.rtc) {
         tracks = this.rtc.getLocalTracks(mediaType);
     }
+
     return tracks;
 };
 
         this.transcriber = new Transcriber();
         // add all existing local audio tracks to the transcriber
         const localAudioTracks = this.getLocalTracks(MediaType.AUDIO);
+
         for (const localAudio of localAudioTracks) {
             this.transcriber.addTrack(localAudio);
         }
         // and all remote audio tracks
         const remoteAudioTracks = this.rtc.getRemoteTracks(MediaType.AUDIO);
+
         for (const remoteTrack of remoteAudioTracks) {
             this.transcriber.addTrack(remoteTrack);
         }
     }
+
     return this.transcriber;
 };
 
     if (track.isVideoTrack()) {
         // Ensure there's exactly 1 local video track in the conference.
         const localVideoTrack = this.rtc.getLocalVideoTrack();
+
         if (localVideoTrack) {
             // Don't be excessively harsh and severe if the API client happens
             // to attempt to add the same local video track twice.
             if (track === localVideoTrack) {
                 return Promise.resolve(track);
             }
+
             return Promise.reject(new Error(
                     'cannot add second video track to the conference'));
 
         // Set up the ssrcHandler for the new track before we add it at the lower levels
         newTrack.ssrcHandler = function(conference, ssrcMap) {
             const trackSSRCInfo = ssrcMap.get(this.getMSID());
+
             if (trackSSRCInfo) {
                 this._setSSRC(trackSSRCInfo);
                 conference.rtc.removeListener(
         this.rtc.addListener(RTCEvents.SENDRECV_STREAMS_CHANGED,
             newTrack.ssrcHandler);
     }
+
     // Now replace the stream at the lower levels
     return this._doReplaceTrack(oldTrack, newTrack)
         .then(() => {
                 // Now handle the addition of the newTrack at the JitsiConference level
                 this._setupNewTrack(newTrack);
             }
+
             return Promise.resolve();
         }, error => Promise.reject(new Error(error)));
 };
     if (this.jingleSession) {
         return this.jingleSession.replaceTrack(oldTrack, newTrack);
     }
+
     return Promise.resolve();
 
 };
                 d =>
                     d.kind === `${newTrack.getTrack().kind}input`
                         && d.label === newTrack.getTrack().label);
+
         if (device) {
             Statistics.sendActiveDeviceListEvent(
                 RTC.getEventDataForActiveDevice(device));
     if (!this.jingleSession) {
         logger.warn('The call haven\'t been started. '
             + 'Cannot generate ssrc info at the moment!');
+
         return null;
     }
+
     return this.jingleSession.generateNewStreamSSRCInfo();
 };
 
     }
 
     const conference = this;
+
+
     return new Promise((resolve, reject) => {
         conference.room.lockRoom(
             password || '',
         throw new Error(`Invalid value for lastN: ${lastN}`);
     }
     const n = Number(lastN);
+
     if (n < -1) {
         throw new RangeError('lastN cannot be smaller than -1');
     }
     = function(countHidden = false) {
 
         let participants = this.getParticipants();
+
         if (!countHidden) {
             participants = participants.filter(p => !p.isHidden());
         }
-    // Add one for the local participant.
+
+        // Add one for the local participant.
         return participants.length + 1;
     };
 
  */
 JitsiConference.prototype.kickParticipant = function(id) {
     const participant = this.getParticipantById(id);
+
     if (!participant) {
         return;
     }
  */
 JitsiConference.prototype.muteParticipant = function(id) {
     const participant = this.getParticipantById(id);
+
     if (!participant) {
         return;
     }
 JitsiConference.prototype.onMemberJoined
     = function(jid, nick, role, isHidden) {
         const id = Strophe.getResourceFromJid(jid);
+
         if (id === 'focus' || this.myUserId() === id) {
             return;
         }
         const participant = new JitsiParticipant(jid, this, nick, isHidden);
+
         participant._role = role;
         this.participants[id] = participant;
         this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, id, participant);
 
 JitsiConference.prototype.onMemberLeft = function(jid) {
     const id = Strophe.getResourceFromJid(jid);
+
     if (id === 'focus' || this.myUserId() === id) {
         return;
     }
     const participant = this.participants[id];
+
     delete this.participants[id];
 
     const removedTracks = this.rtc.removeRemoteTracks(id);
 JitsiConference.prototype.onUserRoleChanged = function(jid, role) {
     const id = Strophe.getResourceFromJid(jid);
     const participant = this.getParticipantById(id);
+
     if (!participant) {
         return;
     }
 JitsiConference.prototype.onDisplayNameChanged = function(jid, displayName) {
     const id = Strophe.getResourceFromJid(jid);
     const participant = this.getParticipantById(id);
+
     if (!participant) {
         return;
     }
 JitsiConference.prototype.onRemoteTrackAdded = function(track) {
     const id = track.getParticipantId();
     const participant = this.getParticipantById(id);
+
     if (!participant) {
         logger.error(`No participant found for id: ${id}`);
+
         return;
     }
 
     }
 
     const emitter = this.eventEmitter;
+
     track.addEventListener(
         JitsiTrackEvents.TRACK_MUTE_CHANGED,
         () => emitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track));
         // Error cause this should never happen unless something is wrong!
         const errmsg = `Rejecting session-initiate from non-focus user: ${
                  jingleSession.peerjid}`;
+
         GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
         logger.error(errmsg);
 
     }
     // add info whether call is cross-region
     let crossRegion = null;
+
     if (window.jitsiRegionInfo) {
         crossRegion = window.jitsiRegionInfo.CrossRegion;
     }
          *  problems between sdp-interop and trying to keep the ssrcs
          *  consistent
          */
+
         if (localTrack.isVideoTrack() && localTrack.isMuted() && !RTCBrowserType.isFirefox()) {
             /**
              * Handles issues when the stream is added before the peerconnection
     // will learn what their SSRC from the new PeerConnection which will be
     // created on incoming call event.
     const self = this;
+
     this.getLocalTracks().forEach(localTrack => {
         // Reset SSRC as it will no longer be valid
         localTrack._setSSRC(null);
     if (!this.dtmfManager) {
         if (!this.jingleSession) {
             logger.warn('cannot sendTones: no jingle session');
+
             return;
         }
 
         const peerConnection = this.jingleSession.peerconnection;
+
         if (!peerConnection) {
             logger.warn('cannot sendTones: no peer connection');
+
             return;
         }
 
         const localAudio = this.getLocalAudioTrack();
+
         if (!localAudio) {
             logger.warn('cannot sendTones: no local audio stream');
+
             return;
         }
         this.dtmfManager = new JitsiDTMFManager(localAudio, peerConnection);
     if (this.room) {
         return this.room.isRecordingSupported();
     }
+
     return false;
 };
 
     if (this.room) {
         return this.room.isSIPCallingSupported();
     }
+
     return false;
 };
 
     if (this.room) {
         return this.room.dial(number);
     }
+
     return new Promise((resolve, reject) => {
         reject(new Error('The conference is not created yet!'));
     });
     if (this.room) {
         return this.room.hangup();
     }
+
     return new Promise((resolve, reject) => {
         reject(new Error('The conference is not created yet!'));
     });
     if (this.room) {
         return this.room.getPhoneNumber();
     }
+
     return null;
 };
 
     if (this.room) {
         return this.room.getPhonePin();
     }
+
     return null;
 };
 
     if (this.jingleSession) {
         return this.jingleSession.getIceConnectionState();
     }
+
     return null;
 };
 
     const data = this.xmpp.getJingleLog();
 
     const metadata = {};
+
     metadata.time = new Date();
     metadata.url = window.location.href;
     metadata.ua = navigator.userAgent;
 
     const log = this.xmpp.getXmppLog();
+
     if (log) {
         metadata.xmpp = log;
     }
  */
 JitsiConference.prototype._onTrackAttach = function(track, container) {
     const ssrc = track.getSSRC();
+
     if (!container.id || !ssrc) {
         return;
     }

JitsiConferenceEventManager.js

 JitsiConferenceEventManager.prototype.setupChatRoomListeners = function() {
     const conference = this.conference;
     const chatRoom = conference.room;
+
     this.chatRoomForwarder = new EventEmitterForwarder(chatRoom,
         this.conference.eventEmitter);
 
 
             Object.keys(chatRoom.connectionTimes).forEach(key => {
                 const value = chatRoom.connectionTimes[key];
+
                 Statistics.analytics.sendEvent(`conference.${key}`, {value});
             });
             Object.keys(chatRoom.xmpp.connectionTimes).forEach(key => {
                 const value = chatRoom.xmpp.connectionTimes[key];
+
                 Statistics.analytics.sendEvent(`xmpp.${key}`, {value});
             });
         });
 
     const eventLogHandler
         = reason => Statistics.sendEventToAll(`conference.error.${reason}`);
+
     chatRoom.addListener(XMPPEvents.SESSION_ACCEPT_TIMEOUT,
         eventLogHandler.bind(null, 'sessionAcceptTimeout'));
 
 
     chatRoom.setParticipantPropertyListener((node, from) => {
         const participant = conference.getParticipantById(from);
+
         if (!participant) {
             return;
         }
                         id: 'recorder_status',
                         status
                     };
+
                     if (error) {
                         logObject.error = error;
                     }
     chatRoom.addListener(XMPPEvents.MESSAGE_RECEIVED,
         (jid, displayName, txt, myJid, ts) => {
             const id = Strophe.getResourceFromJid(jid);
+
             conference.eventEmitter.emit(JitsiConferenceEvents.MESSAGE_RECEIVED,
                 id, txt, ts);
         });
         (jid, status) => {
             const id = Strophe.getResourceFromJid(jid);
             const participant = conference.getParticipantById(id);
+
             if (!participant || participant._status === status) {
                 return;
             }
 
     chatRoom.addPresenceListener('startmuted', (data, from) => {
         let isModerator = false;
+
         if (conference.myUserId() === from && conference.isModerator()) {
             isModerator = true;
         } else {
             const participant = conference.getParticipantById(from);
+
             if (participant && participant.isModerator()) {
                 isModerator = true;
             }
     chatRoom.addPresenceListener('devices', (data, from) => {
         let isAudioAvailable = false;
         let isVideoAvailable = false;
+
         data.children.forEach(config => {
             if (config.tagName === 'audio') {
                 isAudioAvailable = config.value === 'true';
         });
 
         let availableDevices;
+
         if (conference.myUserId() === from) {
             availableDevices = conference.availableDevices;
         } else {
             const participant = conference.getParticipantById(from);
+
             if (!participant) {
                 return;
             }
 
     rtc.addListener(RTCEvents.DATA_CHANNEL_OPEN, () => {
         const now = window.performance.now();
+
         logger.log('(TIME) data channel opened ', now);
         conference.room.connectionTimes['data.channel.opened'] = now;
         Statistics.analytics.sendEvent('conference.dataChannel.open',
     rtc.addListener(RTCEvents.ENDPOINT_MESSAGE_RECEIVED,
         (from, payload) => {
             const participant = conference.getParticipantById(from);
+
             if (participant) {
                 conference.eventEmitter.emit(
                     JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED,
  */
 JitsiConferenceEventManager.prototype.setupXMPPListeners = function() {
     const conference = this.conference;
+
     conference.xmpp.caps.addListener(XMPPEvents.PARTCIPANT_FEATURES_CHANGED,
         from => {
             const participant = conference.getParticipantId(
                 Strophe.getResourceFromJid(from));
+
             if(participant) {
                 conference.eventEmitter.emit(
                     JitsiConferenceEvents.PARTCIPANT_FEATURES_CHANGED,
  */
 JitsiConferenceEventManager.prototype.setupStatisticsListeners = function() {
     const conference = this.conference;
+
     if(!conference.statistics) {
         return;
     }
 
     conference.statistics.addAudioLevelListener((ssrc, level) => {
         const resource = conference.rtc.getResourceBySSRC(ssrc);
+
         if (!resource) {
             return;
         }
             }
 
             const id = conference.rtc.getResourceBySSRC(ssrc);
+
             if (!id) {
                 return;
             }
 
             // ssrc to resolution map for user id
             const idResolutions = id2resolution[id] || {};
+
             idResolutions[ssrc] = resolution;
 
             id2resolution[id] = idResolutions;
     conference.statistics.addByteSentStatsListener(stats => {
         conference.getLocalTracks(MediaType.AUDIO).forEach(track => {
             const ssrc = track.getSSRC();
+
             if (!ssrc || !stats.hasOwnProperty(ssrc)) {
                 return;
             }

JitsiConnection.js

 const JitsiConference = require('./JitsiConference');
+
 import * as JitsiConnectionEvents from './JitsiConnectionEvents';
 import XMPP from './modules/xmpp/xmpp';
 const Statistics = require('./modules/statistics/statistics');

JitsiMediaDevices.js

     setAudioOutputDevice(deviceId) {
 
         const availableDevices = RTC.getCurrentlyAvailableMediaDevices();
+
         if (availableDevices && availableDevices.length > 0) {
             // if we have devices info report device to stats
             // normally this will not happen on startup as this method is called

JitsiMeetJS.js

     const order = Resolutions[resolution].order;
     let res = null;
     let resName = null;
+
     Object.keys(Resolutions).forEach(resolution => {
         const value = Resolutions[resolution];
+
         if (!res || (res.order < value.order && value.order < order)) {
             resName = resolution;
             res = value;
         }
     });
+
     return resName;
 }
 
         if (window.jitsiRegionInfo
             && Object.keys(window.jitsiRegionInfo).length > 0) {
             const logObject = {};
+
             for (const attr in window.jitsiRegionInfo) {
                 if (window.jitsiRegionInfo.hasOwnProperty(attr)) {
                     logObject[attr] = window.jitsiRegionInfo[attr];
                 component: 'lib-jitsi-meet',
                 version: this.version
             };
+
             Statistics.sendLog(JSON.stringify(logObject));
         }
 
                     for(let i = 0; i < tracks.length; i++) {
                         const track = tracks[i];
                         const mStream = track.getOriginalStream();
+
                         if(track.getType() === MediaType.AUDIO) {
                             Statistics.startLocalStats(mStream,
                                 track.setAudioLevel.bind(track));
                 // set real device ids
                 const currentlyAvailableMediaDevices
                     = RTC.getCurrentlyAvailableMediaDevices();
+
                 if (currentlyAvailableMediaDevices) {
                     for(let i = 0; i < tracks.length; i++) {
                         const track = tracks[i];
+
                         track._setRealDeviceIdFromDeviceList(
                             currentlyAvailableMediaDevices);
                     }
                 }
 
                 return tracks;
-            }).catch(error => {
+            })
+            .catch(error => {
                 promiseFulfilled = true;
 
                 if(error.name === JitsiTrackErrors.UNSUPPORTED_RESOLUTION) {
                         id: 'chrome_extension_user_canceled',
                         message: error.message
                     };
+
                     Statistics.sendLog(JSON.stringify(logObject));
                     Statistics.analytics.sendEvent(
                         'getUserMedia.userCancel.extensionInstall');
                         id: 'usermedia_missing_device',
                         status: error.gum.devices
                     };
+
                     Statistics.sendLog(JSON.stringify(logObject));
                     Statistics.analytics.sendEvent(
                         `getUserMedia.deviceNotFound.${
                         = addDeviceTypeToAnalyticsEvent(
                             'getUserMedia.failed',
                             options);
+
                     Statistics.analytics.sendEvent(
                         `${event}.${error.name}`,
                         {value: options});
     isDeviceListAvailable() {
         logger.warn('This method is deprecated, use '
             + 'JitsiMeetJS.mediaDevices.isDeviceListAvailable instead');
+
         return this.mediaDevices.isDeviceListAvailable();
     },
     /**
     isDeviceChangeAvailable(deviceType) {
         logger.warn('This method is deprecated, use '
             + 'JitsiMeetJS.mediaDevices.isDeviceChangeAvailable instead');
+
         return this.mediaDevices.isDeviceChangeAvailable(deviceType);
     },
     /**

doc/example/example.js

         return;
     }
     const participant = track.getParticipantId();
+
     if(!remoteTracks[participant]) {
         remoteTracks[participant] = [];
     }
     const idx = remoteTracks[participant].push(track);
+
     track.addEventListener(
         JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
         audioLevel => console.log(`Audio Level remote: ${audioLevel}`));
             console.log(
                 `track audio output device was changed to ${deviceId}`));
     const id = participant + track.getType() + idx;
+
     if(track.getType() == 'video') {
         $('body').append(`<video autoplay='1' id='${participant}video${idx}' />`);
     } else {
         return;
     }
     const tracks = remoteTracks[id];
+
     for(let i = 0; i < tracks.length; i++) {
         tracks[i].detach($(`#${id}${tracks[i].getType()}`));
     }
 }
 
 let isVideo = true;
+
 function switchVideo() { // eslint-disable-line no-unused-vars
     isVideo = !isVideo;
     if(localTracks[1]) {
                 });
             localTracks[1].attach($('#localVideo1')[0]);
             room.addTrack(localTracks[1]);
-        }).catch(error => {
-            console.log(error);
-        });
+        })
+        .catch(error => console.log(error));
 }
 
 function changeAudioOutput(selected) { // eslint-disable-line no-unused-vars
     // The URL to the Firefox extension for desktop sharing.
     desktopSharingFirefoxExtensionURL: null
 };
-JitsiMeetJS.init(initOptions).then(() => {
-    connection = new JitsiMeetJS.JitsiConnection(null, null, options);
 
-    connection.addEventListener(JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED, onConnectionSuccess);
-    connection.addEventListener(JitsiMeetJS.events.connection.CONNECTION_FAILED, onConnectionFailed);
-    connection.addEventListener(JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED, disconnect);
+JitsiMeetJS.init(initOptions)
+    .then(() => {
+        connection = new JitsiMeetJS.JitsiConnection(null, null, options);
+
+        connection.addEventListener(
+            JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED,
+            onConnectionSuccess);
+        connection.addEventListener(
+            JitsiMeetJS.events.connection.CONNECTION_FAILED,
+            onConnectionFailed);
+        connection.addEventListener(
+            JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED,
+            disconnect);
 
-    JitsiMeetJS.mediaDevices.addEventListener(JitsiMeetJS.events.mediaDevices.DEVICE_LIST_CHANGED, onDeviceListChanged);
+        JitsiMeetJS.mediaDevices.addEventListener(
+            JitsiMeetJS.events.mediaDevices.DEVICE_LIST_CHANGED,
+            onDeviceListChanged);
 
-    connection.connect();
-    JitsiMeetJS.createLocalTracks({devices: ['audio', 'video']})
-        .then(onLocalTracks).catch(error => {
-            throw error;
-        });
-}).catch(error => {
-    console.log(error);
-});
+        connection.connect();
+        JitsiMeetJS.createLocalTracks({devices: ['audio', 'video']})
+            .then(onLocalTracks)
+            .catch(error => {
+                throw error;
+            });
+    })
+    .catch(error => console.log(error));
 
 if (JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
     JitsiMeetJS.mediaDevices.enumerateDevices(devices => {

modules/DTMF/JitsiDTMFManager.js

 
 function JitsiDTMFManager(localAudio, peerConnection) {
     const audioTrack = localAudio.getTrack();
+
     if (!audioTrack) {
         throw new Error('Failed to initialize DTMFSender: no audio track.');
     }

modules/RTC/DataChannels.js

             } else if ('EndpointConnectivityStatusChangeEvent' === colibriClass) {
                 const endpoint = obj.endpoint;
                 const isActive = obj.active === 'true';
+
                 logger.info(
                     `Endpoint connection status changed: ${endpoint} active ? ${
                         isActive}`);
     dataChannel.onclose = function() {
         logger.info('The Data Channel closed', dataChannel);
         const idx = self._dataChannels.indexOf(dataChannel);
+
         if (idx > -1) {
             self._dataChannels = self._dataChannels.splice(idx, 1);
         }
     const tail = xxx.substring(1);
     const lower = head.toLowerCase() + tail;
     const upper = head.toUpperCase() + tail;
+
     logger.log(
             `sending ${lower} endpoint changed notification to the bridge: `,
             userResource);
         if (thisArg) {
             return dataChannels.some(callback, thisArg);
         }
+
         return dataChannels.some(callback);
 
     }
+
     return false;
 
 };
     if(!this._some(dataChannel => {
         if (dataChannel.readyState == 'open') {
             dataChannel.send(JSON.stringify(jsonObject));
+
             return true;
         }
     })) {

modules/RTC/JitsiLocalTrack.js

     if(this.isVideoTrack() && this.videoType === VideoType.CAMERA) {
         const _onNoDataFromSourceError
             = this._onNoDataFromSourceError.bind(this);
+
         this._setHandler('track_mute', () => {
             if(this._checkForCameraIssues()) {
                 const now = window.performance.now();
+
                 this._noDataFromSourceTimeout
                     = setTimeout(_onNoDataFromSourceError, 3000);
                 this._setHandler('track_unmute', () => {
 JitsiLocalTrack.prototype._fireNoDataFromSourceEvent = function() {
     this.eventEmitter.emit(JitsiTrackEvents.NO_DATA_FROM_SOURCE);
     const eventName = `${this.getType()}.no_data_from_source`;
+
     Statistics.analytics.sendEvent(eventName);
     const log = {name: eventName};
+
     if (this.isAudioTrack()) {
         log.isReceivingData = this._isReceivingData();
     }
             devices: [ MediaType.VIDEO ],
             facingMode: this.getCameraFacingMode()
         };
+
         if (this.resolution) {
             streamOptions.resolution = this.resolution;
         }
 = function(successCallback, errorCallback) {
     if (!this.conference) {
         successCallback();
+
         return;
     }
 
     if (this.isVideoTrack() && !this.isActive()) {
         return true;
     }
+
     return !this.track || !this.track.enabled;
 
 };
     } else if(this.ssrc && this.ssrc.ssrcs && this.ssrc.ssrcs.length) {
         return this.ssrc.ssrcs[0];
     }
+
     return null;
 
 };
     // the conference(and through the XMPP chat room ???) instead
     const iceConnectionState
         = this.conference ? this.conference.getConnectionState() : null;
+
     if(this._testByteSent && 'connected' === iceConnectionState) {
         setTimeout(() => {
             if(this._bytesSent <= 0) {
     if(!this.stream) {
         return false;
     }
+
     // In older version of the spec there is no muted property and
     // readyState can have value muted. In the latest versions
     // readyState can have values "live" and "ended" and there is

modules/RTC/JitsiRemoteTrack.js

 /* global */
 
 const JitsiTrack = require('./JitsiTrack');
+
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 const RTCBrowserType = require('./RTCBrowserType');
     const type = this.isVideoTrack() ? 'video' : 'audio';
 
     const now = window.performance.now();
+
     console.log(`(TIME) Render ${type}:\t`, now);
     this.conference.getConnectionTimes()[`${type}.render`] = now;
 
         - this.conference.getConnectionTimes()['muc.joined'])
         - (window.connectionTimes['obtainPermissions.end']
         - window.connectionTimes['obtainPermissions.start']);
+
     this.conference.getConnectionTimes()[`${type}.ttfm`] = ttfm;
     console.log(`(TIME) TTFM ${type}:\t`, ttfm);
     let eventName = `${type}.ttfm`;
+
     if(this.hasBeenMuted) {
         eventName += '.muted';
     }

modules/RTC/JitsiTrack.js

     }
 
     const originalStop = stream.stop;
+
     stream.stop = function() {
         originalStop.apply(stream);
         if (jitsiTrack.isActive()) {
     if (this.isAudioTrack()) {
         return 'mic';
     }
+
     return this.videoType ? this.videoType : 'default';
 
 };
 JitsiTrack.prototype.detach = function(container) {
     for (let cs = this.containers, i = cs.length - 1; i >= 0; --i) {
         const c = cs[i];
+
         if (!container) {
             RTCUtils.attachMediaStream(c, null);
         }
     if(this.stream) {
         return RTCUtils.getStreamID(this.stream);
     }
+
     return null;
 
 };
     if(typeof this.stream.active !== 'undefined') {
         return this.stream.active;
     }
+
     return true;
 
 };
 JitsiTrack.prototype.getMSID = function() {
     const streamId = this.getStreamId();
     const trackId = this.getTrackId();
+
+
     return streamId && trackId ? `${streamId} ${trackId}` : null;
 };
 

modules/RTC/RTC.js

 function createLocalTracks(tracksInfo, options) {
     const newTracks = [];
     let deviceId = null;
+
     tracksInfo.forEach(trackInfo => {
         if (trackInfo.mediaType === MediaType.AUDIO) {
             deviceId = options.micDeviceId;
                 trackInfo.resolution,
                 deviceId,
                 options.facingMode);
+
         newTracks.push(localTrack);
     });
+
     return newTracks;
 }
 
                 deviceId => {
                     const remoteAudioTracks
                         = this.getRemoteTracks(MediaType.AUDIO);
+
                     for (const track of remoteAudioTracks) {
                         track.setAudioOutput(deviceId);
                     }
         return RTCUtils.obtainAudioAndVideoPermissions(options).then(
             tracksInfo => {
                 const tracks = createLocalTracks(tracksInfo, options);
+
+
                 return tracks.some(track => !track._isReceivingData())
                     ? Promise.reject(
                         new JitsiTrackError(
 
     static init(options = {}) {
         this.options = options;
+
         return RTCUtils.init(this.options);
     }
 
 
         this.peerConnections.set(newConnection.id, newConnection);
         this.peerConnectionIdCounter += 1;
+
         return newConnection;
     }
 
      */
     _removePeerConnection(traceablePeerConnection) {
         const id = traceablePeerConnection.id;
+
         if (this.peerConnections.has(id)) {
             // NOTE Remote tracks are not removed here.
             this.peerConnections.delete(id);
+
             return true;
         }
+
         return false;
 
     }
      */
     getLocalVideoTrack() {
         const localVideo = this.getLocalTracks(MediaType.VIDEO);
+
+
         return localVideo.length ? localVideo[0] : undefined;
     }
 
      */
     getLocalAudioTrack() {
         const localAudio = this.getLocalTracks(MediaType.AUDIO);
+
+
         return localAudio.length ? localAudio[0] : undefined;
     }
 
      */
     getLocalTracks(mediaType) {
         let tracks = this.localTracks.slice();
+
         if (mediaType !== undefined) {
             tracks = tracks.filter(
                 track => track.getType() === mediaType);
         }
+
         return tracks;
     }
 
                 }
             }
         }
+
         return remoteTracks;
     }
 
         if (this.remoteTracks[resource]) {
             return this.remoteTracks[resource][type];
         }
+
         return null;
 
     }
      */
     setAudioMute(value) {
         const mutePromises = [];
+
         this.getLocalTracks(MediaType.AUDIO).forEach(audioTrack => {
             // this is a Promise
             mutePromises.push(value ? audioTrack.mute() : audioTrack.unmute());
         });
-        // we return a Promise from all Promises so we can wait for their execution
+
+        // We return a Promise from all Promises so we can wait for their
+        // execution.
         return Promise.all(mutePromises);
     }
 
     removeLocalTrack(track) {
         const pos = this.localTracks.indexOf(track);
+
         if (pos === -1) {
             return;
         }
 
             delete this.remoteTracks[owner];
         }
+
         return removedTracks;
     }
 
                         && mediaTrack.getStreamId() == streamId
                         && mediaTrack.getTrackId() == trackId) {
                         result = mediaTrack;
+
                         return true;
                     }
+
                     return false;
 
                 });
             return;
         }
         const audioTrack = this.getRemoteAudioTrack(resource);
+
         if(audioTrack) {
             audioTrack.setAudioLevel(audioLevel);
         }
         }
 
         const track = this.getRemoteTrackBySSRC(ssrc);
+
+
         return track ? track.getParticipantId() : null;
     }
 
      */
     handleRemoteTrackMute(type, isMuted, from) {
         const track = this.getRemoteTrackByType(type, from);
+
         if (track) {
             track.setMute(isMuted);
         }
      */
     handleRemoteTrackVideoTypeChanged(value, from) {
         const videoTrack = this.getRemoteVideoTrack(from);
+
         if (videoTrack) {
             videoTrack._setVideoType(value);
         }

modules/RTC/RTCBrowserType.js

      */
     getBrowserName() {
         let browser;
+
         if (RTCBrowserType.isAndroid()) {
             browser = 'android';
         } else {
             browser = currentBrowser.split('rtc_browser.')[1];
         }
+
         return browser;
     },
 
         // We can assume that user agent is chrome, because it's
         // enforced when 'ext' streaming method is set
         const ver = parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
+
         logger.log(`This appears to be Chrome, ver: ${ver}`);
+
         return ver;
     }
+
     return null;
 }
 
 function detectOpera() {
     const userAgent = navigator.userAgent;
+
     if (userAgent.match(/Opera|OPR/)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_OPERA;
         const version = userAgent.match(/(Opera|OPR) ?\/?(\d+)\.?/)[2];
+
         logger.info(`This appears to be Opera, ver: ${version}`);
+
         return version;
     }
+
     return null;
 }
 
         currentBrowser = RTCBrowserType.RTC_BROWSER_FIREFOX;
         const version = parseInt(
             navigator.userAgent.match(/Firefox\/([0-9]+)\./)[1], 10);
+
         logger.log(`This appears to be Firefox, ver: ${version}`);
+
         return version;
     }
+
     return null;
 }
 
     if (/^((?!chrome).)*safari/i.test(navigator.userAgent)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_SAFARI;
         logger.info('This appears to be Safari');
+
         // FIXME detect Safari version when needed
         return 1;
     }
+
     return null;
 }
 
     const ua = window.navigator.userAgent;
 
     const msie = ua.indexOf('MSIE ');
+
     if (msie > 0) {
         // IE 10 or older => return version number
         version = parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
     }
 
     const trident = ua.indexOf('Trident/');
+
     if (!version && trident > 0) {
         // IE 11 => return version number
         const rv = ua.indexOf('rv:');
+
         version = parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
     }
 
     const edge = ua.indexOf('Edge/');
+
     if (!version && edge > 0) {
         // IE 12 => return version number
         version = parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
         currentBrowser = RTCBrowserType.RTC_BROWSER_IEXPLORER;
         logger.info(`This appears to be IExplorer, ver: ${version}`);
     }
+
     return version;
 }
 
  */
 function detectElectron() {
     const userAgent = navigator.userAgent;
+
     if (userAgent.match(/Electron/)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_ELECTRON;
         const version = userAgent.match(/Electron\/([\d.]+)/)[1];
+
         logger.info(`This appears to be Electron, ver: ${version}`);
+
         return version;
     }
+
     return null;
 }
 
 function detectNWJS() {
     const userAgent = navigator.userAgent;
+
     if (userAgent.match(/JitsiMeetNW/)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_NWJS;
         const version = userAgent.match(/JitsiMeetNW\/([\d.]+)/)[1];
+
         logger.info(`This appears to be JitsiMeetNW, ver: ${version}`);
+
         return version;
     }
+
     return null;
 }
 
     // If we're remote debugging a React Native app, it may be treated as
     // Chrome. Check navigator.product as well and always return some version
     // even if we can't get the real one.
+
     if (match || navigator.product === 'ReactNative') {
         currentBrowser = RTCBrowserType.RTC_BROWSER_REACT_NATIVE;
         let name;
+
         if (match && match.length > 2) {
             name = match[1];
             version = match[2];
         // We're not running in a React Native environment.
         version = null;
     }
+
     return version;
 }
 
         detectSafari
     ];
     // Try all browser detectors
+
     for (let i = 0; i < detectors.length; i++) {
         version = detectors[i]();
         if (version) {
     }
     logger.warn('Browser type defaults to Safari ver 1');
     currentBrowser = RTCBrowserType.RTC_BROWSER_SAFARI;
+
     return 1;
 }
 

modules/RTC/RTCUIHelper.js

      */
     findVideoElement(containerElement) {
         const videoElemName = RTCUIHelper.getVideoElementName();
+
         if (!RTCBrowserType.isTemasysPluginUsed()) {
             return $(containerElement).find(videoElemName)[0];
         }
         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);
             }
+
             return matching.parent()[0];
         }
 

modules/RTC/RTCUtils.js

  * ready. Otherwise it is too early to assume that the devices listing is not
  * supported.
  */
+
 function initRawEnumerateDevicesWithCallback() {
     rawEnumerateDevicesWithCallback = navigator.mediaDevices
         && navigator.mediaDevices.enumerateDevices
             const errmsg
                 = '\'screen\' WebRTC media source is supported only in Chrome'
                     + ' and with Temasys plugin';
+
             GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
             logger.error(errmsg);
         }
         return true;
     }
 
-    return newDevices.map(mediaDeviceInfoToJSON).sort().join('')
-        !== currentlyAvailableMediaDevices.map(mediaDeviceInfoToJSON).sort().join('');
+    return (
+        newDevices
+                .map(mediaDeviceInfoToJSON)
+                .sort()
+                .join('')
+            !== currentlyAvailableMediaDevices
+                .map(mediaDeviceInfoToJSON)
+                .sort()
+                .join(''));
 
     function mediaDeviceInfoToJSON(info) {
         return JSON.stringify({
 
     const device = options.devices.splice(0, 1);
     const devices = [];
+
     devices.push(device);
     options.deviceGUM[device](
         stream => {
         // (with a result which meets our requirements expressed bellow) calling
         // getUserMedia once for both audio and video.
         const audioVideo = streams.audioVideo;
+
         if (audioVideo) {
             const audioTracks = audioVideo.getAudioTracks();
+
             if (audioTracks.length) {
                 // eslint-disable-next-line new-cap
                 audioStream = new webkitMediaStream();
             }
 
             const videoTracks = audioVideo.getVideoTracks();
+
             if (videoTracks.length) {
                 // eslint-disable-next-line new-cap
                 videoStream = new webkitMediaStream();
 function defaultSetVideoSrc(element, stream) {
     // srcObject
     let srcObjectPropertyName = 'srcObject';
+
     if (!(srcObjectPropertyName in element)) {
         srcObjectPropertyName = 'mozSrcObject';
         if (!(srcObjectPropertyName in element)) {
     }
     if (srcObjectPropertyName) {
         element[srcObjectPropertyName] = stream;
+
         return;
     }
 
     // src
     let src;
+
     if (stream) {
         src = stream.jitsiObjectURL;
         // Save the created URL for stream so we can reuse it and not keep
         return new Promise((resolve, reject) => {
             if (RTCBrowserType.isFirefox()) {
                 const FFversion = RTCBrowserType.getFirefoxVersion();
+
                 if (FFversion < 40) {
                     rejectWithWebRTCNotSupported(
                         `Firefox version too old: ${FFversion}.`
                             element.play();
                         }
                     }
+
                     return element;
                 });
                 this.getStreamID = function(stream) {
                     let id = stream.id;
+
                     if (!id) {
                         let tracks = stream.getVideoTracks();
+
                         if (!tracks || tracks.length === 0) {
                             tracks = stream.getAudioTracks();
                         }
                         id = tracks[0].id;
                     }
+
                     return SDPUtil.filter_special_chars(id);
                 };
                 RTCSessionDescription = mozRTCSessionDescription; // eslint-disable-line
 
                 this.peerconnection = webkitRTCPeerConnection;
                 const getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
+
                 if (navigator.mediaDevices) {
                     this.getUserMedia = wrapGetUserMedia(getUserMedia);
                     this.enumerateDevices = wrapEnumerateDevices(
                 }
                 this.attachMediaStream = wrapAttachMediaStream((element, stream) => {
                     defaultSetVideoSrc(element, stream);
+
                     return element;
                 });
                 this.getStreamID = function(stream) {
                     // XXX The return statement is affected by automatic
                     // semicolon insertion (ASI). No line terminator is allowed
                     // between the return keyword and the expression.
+
                     return (
                         typeof id === 'number'
                             ? id
                             // The container must be visible in order to play or
                             // attach the stream when Temasys plugin is in use
                             const containerSel = $(element);
+
                             if (RTCBrowserType.isTemasysPluginUsed()
                                     && !containerSel.is(':visible')) {
                                 containerSel.show();
                             }
                             const video = stream.getVideoTracks().length > 0;
+
                             if (video && !$(element).is(':visible')) {
                                 throw new Error(
                                     'video element must be visible to attach'
 
         options = options || {};
         const dsOptions = options.desktopSharingExtensionExternalInstallation;
+
+
         return new Promise((resolve, reject) => {
             const successCallback = function(stream) {
                 resolve(handleLocalStream(stream, options.resolution));
                 });
             } else {
                 const hasDesktop = options.devices.indexOf('desktop') > -1;
+
                 if (hasDesktop) {
                     options.devices.splice(options.devices.indexOf('desktop'), 1);
                 }
         if (!rtcReady) {
             throw new Error('WebRTC not ready yet');
         }
+
         return Boolean(navigator.mediaDevices
             && navigator.mediaDevices.enumerateDevices
             && typeof MediaStreamTrack !== 'undefined'
         if (rtcReady) {
             return Promise.resolve();
         }
+
         return new Promise(resolve => {
             const listener = () => {
                 eventEmitter.removeListener(RTCEvents.RTC_READY, listener);
                 resolve();
             };
+
             eventEmitter.addListener(RTCEvents.RTC_READY, listener);
                 // We have no failed event, so... it either resolves or nothing
                 // happens
 
         // if we have done createObjectURL, lets clean it
         const url = mediaStream.jitsiObjectURL;
+
         if (url) {
             delete mediaStream.jitsiObjectURL;
             (URL || webkitURL).revokeObjectURL(url);
             'label':    device.label,
             'groupId':  device.groupId
         };
+
         devices.push(deviceData);
+
         return { deviceList: devices };
     }
 }

modules/RTC/ScreenObtainer.js

 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 const RTCBrowserType = require('./RTCBrowserType');
+
 import JitsiTrackError from '../../JitsiTrackError';
 import * as JitsiTrackErrors from '../../JitsiTrackErrors';
 
      */
     init(options, gum) {
         let obtainDesktopStream = null;
+
         this.options = options = options || {};
         gumFunction = gum;
 
                         // I cannot find documentation about "InvalidStateError"
                         // but this is what we are receiving from GUM when the
                         // streamId for the desktop sharing is "".
+
                         if (error && error.name == 'InvalidStateError') {
                             jitsiError = new JitsiTrackError(
                                 JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED
     obtainScreenOnFirefox(options, callback, errorCallback) {
         let extensionRequired = false;
         const { desktopSharingFirefoxMaxVersionExtRequired } = this.options;
+
         if (desktopSharingFirefoxMaxVersionExtRequired === -1
             || (desktopSharingFirefoxMaxVersionExtRequired >= 0
                 && RTCBrowserType.getFirefoxVersion()
 
         if (!extensionRequired || firefoxExtInstalled === true) {
             obtainWebRTCScreen(options, callback, errorCallback);
+
             return;
         }
 
                 300);
             logger.log(
                 'Waiting for detection of jidesha on firefox to finish.');
+
             return;
         }
 
                             .then(() => {
                                 doGetStreamFromExtension(this.options,
                                     streamCallback, failCallback);
-                            }).catch(() => {
+                            })
+                            .catch(() => {
                                 this.handleExtensionInstallationError(options,
                                     streamCallback, failCallback);
                             });
             options.listener('waitingForExtension', webStoreInstallUrl);
             this.checkForChromeExtensionOnInterval(options, streamCallback,
                 failCallback, e);
+
             return;
         }
 
         if (options.checkAgain() === false) {
             failCallback(new JitsiTrackError(
                 JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR));
+
             return;
         }
         waitForExtensionAfterInstall(this.options, options.interval, 1)
                 options.listener('extensionFound');
                 this.obtainScreenFromExtension(options,
                     streamCallback, failCallback);
-            }).catch(() => {
+            })
+            .catch(() => {
                 this.checkForChromeExtensionOnInterval(options,
                     streamCallback, failCallback);
             });
         const s2 = extVersion.split('.');
 
         const len = Math.max(s1.length, s2.length);
+
         for (let i = 0; i < len; i++) {
             let n1 = 0,
                 n2 = 0;
     } catch (e) {
         GlobalOnErrorHandler.callErrorHandler(e);
         logger.error('Failed to parse extension version', e);
+
         return true;
     }
 }
     if (typeof chrome === 'undefined' || !chrome || !chrome.runtime) {
         // No API, so no extension for sure
         callback(false, false);
+
         return;
     }
     chrome.runtime.sendMessage(
                 logger.warn(
                     'Extension not installed?: ', chrome.runtime.lastError);
                 callback(false, false);
+
                 return;
             }
             // Check installed extension version
             const extVersion = response.version;
+
             logger.log(`Extension version is: ${extVersion}`);
             const updateRequired
                 = isUpdateRequired(
                     options.desktopSharingChromeMinExtVersion,
                     extVersion);
+
             callback(!updateRequired, updateRequired);
         }
     );
             if (!response) {
                 // possibly re-wraping error message to make code consistent
                 const lastError = chrome.runtime.lastError;
+
                 failCallback(lastError instanceof Error
                     ? lastError
                     : new JitsiTrackError(
                         JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR,
                         lastError));
+
                 return;
             }
             logger.log('Response from extension: ', response);
     if(retries === 0) {
         return Promise.reject();
     }
+
     return new Promise((resolve, reject) => {
         let currentRetries = retries;
         const interval = window.setInterval(() => {
         if(response.streamId === '') {
             onFailure(new JitsiTrackError(
                 JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED));
+
             return;
         }
 
     }
     if (!options.desktopSharingFirefoxExtId) {
         firefoxExtInstalled = false;
+
         return;
     }
 
     const img = document.createElement('img');
+
     img.onload = () => {
         logger.log('Detected firefox screen sharing extension.');
         firefoxExtInstalled = true;
     const src
         = `chrome://${options.desktopSharingFirefoxExtId.replace('@', '.')
             }/content/${document.location.hostname}.png`;
+
     img.setAttribute('src', src);
 }
 

modules/RTC/TraceablePeerConnection.js

      * <tt>TracablePeerConnection</tt>.
      * @type {RTC}
      */
+
     this.rtc = rtc;
     /**
      * The peer connection identifier assigned by the RTC module.
     this.signalingLayer = signalingLayer;
     this.options = options;
     let RTCPeerConnectionType = null;
+
     if (RTCBrowserType.isFirefox()) {
         RTCPeerConnectionType = mozRTCPeerConnection;
     } else if (RTCBrowserType.isTemasysPluginUsed()) {
      */
     this.maxstats = 0;
     const Interop = require('sdp-interop').Interop;
+
     this.interop = new Interop();
     const Simulcast = require('sdp-simulcast');
+
     this.simulcast = new Simulcast({numOfLayers: SIMULCAST_LAYERS,
         explodeRemoteSimulcast: false});
     this.sdpConsistency = new SdpConsistency();
             self.peerconnection.getStats(stats => {
                 const results = stats.result();
                 const now = new Date();
+
                 for (let i = 0; i < results.length; ++i) {
                     results[i].names().forEach(name => {
                         const id = `${results[i].id}-${name}`;
+
                         if (!self.stats[id]) {
                             self.stats[id] = {
                                 startTime: now,
     if (!RTC.isUserStream(stream)) {
         logger.info(
             'Ignored remote \'stream added\' event for non-user stream', stream);
+
         return;
     }
     // Bind 'addtrack'/'removetrack' event handlers
     }
     // Call remoteTrackAdded for each track in the stream
     const streamAudioTracks = stream.getAudioTracks();
+
     for (const audioTrack of streamAudioTracks) {
         this._remoteTrackAdded(stream, audioTrack);
     }
     const streamVideoTracks = stream.getVideoTracks();
+
     for (const videoTrack of streamVideoTracks) {
         this._remoteTrackAdded(stream, videoTrack);
     }
             new Error(
                 `MediaType undefined for remote track, stream id: ${streamId}`
             ));
+
         // Abort
         return;
     }
     const mediaLines
         = remoteSDP.media.filter(
             mediaLines => mediaLines.startsWith(`m=${mediaType}`));
+
     if (!mediaLines.length) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error(
                 `No media lines for type ${mediaType
                      } found in remote SDP for remote track: ${streamId}`));
+
         // Abort
         return;
     }
         line => {
             const msid
                 = RTCBrowserType.isTemasysPluginUsed() ? 'mslabel' : 'msid';
+
+
             return line.indexOf(`${msid}:${streamId}`) !== -1;
         });
     if (!ssrcLines.length) {
             new Error(
                 `No SSRC lines for streamId ${streamId
                      } for remote track, media type: ${mediaType}`));
+
         // Abort
         return;
     }
                 `No SSRC owner known for: ${trackSsrc
                      } for remote track, msid: ${streamId
                      } media type: ${mediaType}`));
+
         // Abort
         return;
     }
     if (!peerMediaInfo) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error(`No peer media info available for: ${ownerEndpointId}`));
+
         // Abort
         return;
     }
 TraceablePeerConnection.prototype._remoteStreamRemoved = function(stream) {
     if (!RTC.isUserStream(stream)) {
         const id = RTC.getStreamID(stream);
+
         logger.info(
             `Ignored remote 'stream removed' event for non-user stream ${id}`);
+
         return;
     }
     // Call remoteTrackRemoved for each track in the stream
     const streamVideoTracks = stream.getVideoTracks();
+
     for (const videoTrack of streamVideoTracks) {
         this._remoteTrackRemoved(stream, videoTrack);
     }
     const streamAudioTracks = stream.getAudioTracks();
+
     for (const audioTrack of streamAudioTracks) {
         this._remoteTrackRemoved(stream, audioTrack);
     }
     if (!streamId) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error('Remote track removal failed - no stream ID'));
+
         // Abort
         return;
     }
     if (!trackId) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error('Remote track removal failed - no track ID'));
+
         // Abort
         return;
     }
     if (typeof desc !== 'object' || desc === null
         || typeof desc.sdp !== 'string') {
         logger.warn('An empty description was passed as an argument.');
+
         return ssrcMap;
     }
 
                                      .map(ssrcStr => parseInt(ssrcStr));
                     const primarySSRC = groupSSRCs[0];
                     // Note that group.semantics is already present
+
                     group.ssrcs = groupSSRCs;
                     if (!groupsMap.has(primarySSRC)) {
                         groupsMap.set(primarySSRC, []);
     if (typeof desc !== 'object' || desc === null
         || typeof desc.sdp !== 'string') {
         logger.warn('An empty description was passed as an argument.');
+
         return desc;
     }
 
 
             if (Array.isArray(mLine.ssrcs)) {
                 let i;
+
                 for (i = 0; i < mLine.ssrcs.length; i++) {
                     if (typeof mLine.ssrcs[i] === 'object'
                         && typeof mLine.ssrcs[i].id !== 'undefined'
     }
 
     const resStr = transform.write(session);
+
+
     return new RTCSessionDescription({
         type: desc.type,
         sdp: resStr
             this.trace('getLocalDescription::postTransform (Plan B)',
                 dumpSDP(desc));
         }
+
         return desc;
     },
     remoteDescription() {
         let desc = this.peerconnection.remoteDescription;
+
         this.trace('getRemoteDescription::preTransform', dumpSDP(desc));
 
         // if we're running on FF, transform to Plan B first.
             this.trace(
                 'getRemoteDescription::postTransform (Plan B)', dumpSDP(desc));
         }
+
         return desc;
     }
 };
+
 Object.keys(getters).forEach(prop => {
     Object.defineProperty(
         TraceablePeerConnection.prototype,
         this.sdpConsistency.setPrimarySsrc(ssrcInfo.ssrcs[0]);
         const simGroup
             = ssrcInfo.groups.find(groupInfo => groupInfo.semantics === 'SIM');
+
         if (simGroup) {
             this.simulcast.setSsrcCache(simGroup.ssrcs);
         }
         const fidGroups
             = ssrcInfo.groups.filter(
                 groupInfo => groupInfo.semantics === 'FID');
+
         if (fidGroups) {
             const rtxSsrcMapping = new Map();
+
             fidGroups.forEach(fidGroup => {
                 const primarySsrc = fidGroup.ssrcs[0];
                 const rtxSsrc = fidGroup.ssrcs[1];
+
                 rtxSsrcMapping.set(primarySsrc, rtxSsrc);
             });
             this.rtxModifier.setSsrcCache(rtxSsrcMapping);
 
 TraceablePeerConnection.prototype.createDataChannel = function(label, opts) {
     this.trace('createDataChannel', label, opts);
+
     return this.peerconnection.createDataChannel(label, opts);
 };
 
             }
 
             const self = this;
+
             this.peerconnection.setLocalDescription(description,
         () => {
             self.trace('setLocalDescriptionOnSuccess');
             if (this.options.preferH264) {
                 const parsedSdp = transform.parse(description.sdp);
                 const videoMLine = parsedSdp.media.find(m => m.type === 'video');
+
                 SDPUtil.preferVideoCodec(videoMLine, 'h264');
                 description.sdp = transform.write(parsedSdp);
             }
             }
 
             const self = this;
+
             this.peerconnection.setRemoteDescription(description,
         () => {
             self.trace('setRemoteDescriptionOnSuccess');
 TraceablePeerConnection.prototype.generateRecvonlySsrc = function() {
     // FIXME replace with SDPUtil.generateSsrc (when it's added)
     const newSSRC = this.generateNewStreamSSRCInfo().ssrcs[0];
+
     logger.info(`Generated new recvonly SSRC: ${newSSRC}`);
     this.sdpConsistency.setPrimarySsrc(newSSRC);
 };
                 //  details)
                 const remoteDescription = new SDP(this.remoteDescription.sdp);
                 const localDescription = new SDP(answer.sdp);
+
                 _fixAnswerRFC4145Setup(remoteDescription, localDescription);
                 answer.sdp = localDescription.raw;
 
  */
 TraceablePeerConnection.prototype.generateNewStreamSSRCInfo = function() {
     let ssrcInfo = {ssrcs: [], groups: []};
+
     if (!this.options.disableSimulcast
         && this.simulcast.isSupported()) {
         for (let i = 0; i < SIMULCAST_LAYERS; i++) {
         //  only want to iterate through the items originally
         //  on the list
         const currNumSsrcs = ssrcInfo.ssrcs.length;
+
         for (let i = 0; i < currNumSsrcs; ++i) {
             const primarySsrc = ssrcInfo.ssrcs[i];
             const rtxSsrc = SDPUtil.generateSsrc();
+
             ssrcInfo.ssrcs.push(rtxSsrc);
             ssrcInfo.groups.push({
                 ssrcs: [primarySsrc, rtxSsrc],
             });
         }
     }
+
     return ssrcInfo;
 };
 

modules/connectivity/ConnectionQuality.js

     if (simulcast) {
         // Find the first format with height no bigger than ours.
         let simulcastFormat = kSimulcastFormats.find(f => f.height <= height);
+
         if (simulcastFormat) {
             // Sum the target fields from all simulcast layers for the given
             // resolution (e.g. 720p + 360p + 180p).
         // See GetMaxDefaultVideoBitrateKbps in
         // media/engine/webrtcvideoengine2.cc from webrtc.org
         const pixels = resolution.width * resolution.height;
+
         if (pixels <= 320 * 240) {
             target = 600;
         } else if (pixels <= 640 * 480) {
     if (millisSinceStart > 60000) {
         return Number.MAX_SAFE_INTEGER;
     }
+
     // According to GCC the send side bandwidth estimation grows with at most
     // 8% per second.
     // https://tools.ietf.org/html/draft-ietf-rmcat-gcc-02#section-5.5
         let quality = 100;
         let packetLoss;
         // TODO: take into account packet loss for received streams
+
         if (this._localStats.packetLoss) {
             packetLoss = this._localStats.packetLoss.upload;
 
             // expected sending bitrate in perfect conditions
             let target
                 = getTarget(this._simulcast, resolution, millisSinceStart);
+
             target = 0.9 * target;
 
             quality = 100 * this._localStats.bitrate.upload / target;
             const diffSeconds
                 = (window.performance.now() - this._lastConnectionQualityUpdate)
                     / 1000;
+
             quality
                 = Math.min(
                     quality,
         // resolution instead. Consider removing this.
         const localVideoTrack
             = this._conference.getLocalVideoTrack();
+
         if (localVideoTrack && localVideoTrack.resolution) {
             data.resolution = localVideoTrack.resolution;
         }

modules/connectivity/ParticipantConnectionStatus.js

      */
     figureOutConnectionStatus(id) {
         const participant = this.conference.getParticipantById(id);
+
         if (!participant) {
             // Probably the participant is no longer in the conference
             // (at the time of writing this code, participant is
             // so we don't care, but let's print the warning for
             // debugging purpose
             logger.warn(`figure out conn status - no participant for: ${id}`);
+
             return;
         }
 
     onTrackRtcMuted(track) {
         const participantId = track.getParticipantId();
         const participant = this.conference.getParticipantById(participantId);
+
         logger.debug(`Detector track RTC muted: ${participantId}`);
         if (!participant) {
             logger.error(`No participant for id: ${participantId}`);
+
             return;
         }
         this.rtcMutedTimestamp[participantId] = Date.now();

modules/settings/Settings.js

  */
 function getLocalStorage() {
     const global = typeof window == 'undefined' ? this : window;
+
+
     return global.localStorage;
 }
 
  */
 function generateJitsiMeetId() {
     const jitsiMeetId = generateUniqueId();
+
     logger.log('generated id', jitsiMeetId);
 
     return jitsiMeetId;
  */
 function generateCallStatsUsername() {
     const username = UsernameGenerator.generateUsername();
+
     logger.log('generated callstats uid', username);
 
     return username;
         this.callStatsUserName;
 
         const localStorage = getLocalStorage();
+
         if (localStorage) {
             this.userId
                 = localStorage.getItem('jitsiMeetId') || generateJitsiMeetId();
      */
     save() {
         const localStorage = getLocalStorage();
+
         if (localStorage) {
             localStorage.setItem('jitsiMeetId', this.userId);
             localStorage.setItem('callStatsUserName', this.callStatsUserName);
      */
     setSessionId(sessionId) {
         const localStorage = getLocalStorage();
+
         if (localStorage) {
             if (sessionId) {
                 localStorage.setItem('sessionId', sessionId);
         // We may update sessionId in localStorage from another JitsiConference
         // instance and that's why we should always re-read it.
         const localStorage = getLocalStorage();
+
+
         return localStorage ? localStorage.getItem('sessionId') : undefined;
     }
 }

modules/statistics/AnalyticsAdapter.js

      */
     drainCachedEvents() {
         const eventCacheCopy = this.eventCache.slice();
+
         this.eventCache = [];
+
         return eventCacheCopy;
     }
 
     sendEvent(action, data = {}) {
         const modifiedData = Object.assign(
             {browserName: this.browserName}, this.permanentProperties, data);
+
         this.analyticsHandlers.forEach(
             analytics => analytics.sendEvent(action, modifiedData));
     }

modules/statistics/CallStats.js

 /* global $, Strophe, callstats */
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
+
 import Settings from '../settings/Settings';
 
 const jsSHA = require('jssha');
     // there is no lib, nothing to report to
     if (err !== 'success') {
         CallStats.initializeFailed = true;
+
         return;
     }
 
     if(!fabricInitialized) {
         CallStats.initializeFailed = true;
         logger.log('callstats fabric not initilized', ret.message);
+
         return;
     }
 
         CallStats.reportsQueue.forEach(function(report) {
             if (report.type === reportType.ERROR) {
                 const error = report.data;
+
                 CallStats._reportError.call(this, error.type, error.error,
                     error.pc);
             } else if (report.type === reportType.EVENT
                 // if we have and event to report and we failed to add fabric
                 // this event will not be reported anyway, returning an error
                 const eventData = report.data;
+
                 callStats.sendFabricEvent(
                     this.peerconnection,
                     eventData.event,
                     eventData.eventData);
             } else if (report.type === reportType.MST_WITH_USERID) {
                 const data = report.data;
+
                 callStats.associateMstWithUserID(
                     this.peerconnection,
                     data.callStatsId,

modules/statistics/LocalStatsCollector.js

 function animateLevel(newLevel, lastLevel) {
     let value = 0;
     const diff = lastLevel - newLevel;
+
     if(diff > 0.2) {
         value = lastLevel - 0.2;
     } else if(diff < -0.4) {
     }
     context.resume();
     const analyser = context.createAnalyser();
+
     analyser.smoothingTimeConstant = WEBAUDIO_ANALYZER_SMOOTING_TIME;
     analyser.fftSize = WEBAUDIO_ANALYZER_FFT_SIZE;
 
     const source = context.createMediaStreamSource(this.stream);
+
     source.connect(analyser);
 
 
     this.intervalId = setInterval(
         () => {
             const array = new Uint8Array(analyser.frequencyBinCount);
+
             analyser.getByteTimeDomainData(array);
             const audioLevel = timeDomainDataToAudioLevel(array);
+
             if (audioLevel != self.audioLevel) {
                 self.audioLevel = animateLevel(audioLevel, self.audioLevel);
                 self.callback(self.audioLevel);

modules/statistics/RTPStatsCollector.js

 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 const RTCBrowserType = require('../RTC/RTCBrowserType');
+
 import * as StatisticsEvents from '../../service/statistics/Events';
 
 /* Whether we support the browser we are running into for logging statistics */
  * by RTCPeerConnection#getStats mapped by RTCBrowserType.
  */
 const KEYS_BY_BROWSER_TYPE = {};
+
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_FIREFOX] = {
     'ssrc': 'ssrc',
     'packetsReceived': 'packetsReceived',
     if(!totalPackets || totalPackets <= 0 || !lostPackets || lostPackets <= 0) {
         return 0;
     }
+
     return Math.round((lostPackets / totalPackets) * 100);
 }
 
      */
     this._browserType = RTCBrowserType.getBrowserType();
     const keys = KEYS_BY_BROWSER_TYPE[this._browserType];
+
     if (!keys) {
         throw `The browser type '${this._browserType}' isn't supported!`;
     }
  */
 StatsCollector.prototype.start = function(startAudioLevelStats) {
     const self = this;
+
     if(startAudioLevelStats) {
         this.audioLevelsIntervalId = setInterval(
             () => {
                 self.peerconnection.getStats(
                     report => {
                         let results = null;
+
                         if (!report || !report.result
                             || typeof report.result != 'function') {
                             results = report;
                 self.peerconnection.getStats(
                     report => {
                         let results = null;
+
                         if (!report || !report.result
                             || typeof report.result != 'function') {
                             // firefox
     // RTCPeerConnection#getStats.
     const keyFromName = function(name) {
         const key = keys[name];
+
         if (key) {
             return key;
         }
     // returned by RTCPeerConnection#getStats associated with a given
     // browser-specific key.
     let itemStatByKey;
+
     switch (this._browserType) {
     case RTCBrowserType.RTC_BROWSER_CHROME:
     case RTCBrowserType.RTC_BROWSER_OPERA:
         // Array in which each element is a key-value pair.
         itemStatByKey = function(item, key) {
             let value;
+
             item.values.some(pair => {
                 if (pair.hasOwnProperty(key)) {
                     value = pair[key];
+
                     return true;
                 }
+
                 return false;
 
             });
+
             return value;
         };
         break;
     }
 
     const getStatValue = this._getStatValue;
+
     function getNonNegativeStat(report, name) {
         let value = getStatValue(report, name);
+
         if (typeof value !== 'number') {
             value = Number(value);
         }
             continue;
         }
         const now = this.currentStatsReport[idx];
+
         try {
             const receiveBandwidth = getStatValue(now, 'receiveBandwidth');
             const sendBandwidth = getStatValue(now, 'sendBandwidth');
+
             if (receiveBandwidth || sendBandwidth) {
                 this.conferenceStats.bandwidth = {
                     'download': Math.round(receiveBandwidth / 1000),
 
         if(now.type == 'googCandidatePair') {
             let active, ip, localip, type;
+
             try {
                 ip = getStatValue(now, 'remoteAddress');
                 type = getStatValue(now, 'transportType');
             }
             // Save the address unless it has been saved already.
             const conferenceStatsTransport = this.conferenceStats.transport;
+
             if(!conferenceStatsTransport.some(
                     t =>
                         t.ip == ip && t.type == type && t.localip == localip)) {
 
             const local = this.currentStatsReport[now.localCandidateId];
             const remote = this.currentStatsReport[now.remoteCandidateId];
+
             this.conferenceStats.transport.push({
                 ip: `${remote.ipAddress}:${remote.portNumber}`,
                 type: local.transport,
 
         const before = this.previousStatsReport[idx];
         const ssrc = getStatValue(now, 'ssrc');
+
         if (!before || !ssrc) {
             continue;
         }
         let isDownloadStream = true;
         let key = 'packetsReceived';
         let packetsNow = getStatValue(now, key);
+
         if (typeof packetsNow === 'undefined'
             || packetsNow === null || packetsNow === '') {
             isDownloadStream = false;
 
         // TODO: clean this mess up!
         let nowBytesTransmitted = getStatValue(now, 'bytesSent');
+
         if(typeof nowBytesTransmitted === 'number'
             || typeof nowBytesTransmitted === 'string') {
             nowBytesTransmitted = Number(nowBytesTransmitted);
 
         const timeMs = now.timestamp - before.timestamp;
         let bitrateReceivedKbps = 0, bitrateSentKbps = 0;
+
         if (timeMs > 0) {
             // TODO is there any reason to round here?
             bitrateReceivedKbps = Math.round((bytesReceived * 8) / timeMs);
         });
 
         const resolution = {height: null, width: null};
+
         try {
             let height, width;
+
             if ((height = getStatValue(now, 'googFrameHeightReceived'))
                 && (width = getStatValue(now, 'googFrameWidthReceived'))) {
                 resolution.height = height;
     let bitrateDownload = 0;
     let bitrateUpload = 0;
     const resolutions = {};
+
     Object.keys(this.ssrc2stats).forEach(
         function(ssrc) {
             const ssrcStats = this.ssrc2stats[ssrc];
             // process packet loss stats
             const loss = ssrcStats.loss;
             const type = loss.isDownloadStream ? 'download' : 'upload';
+
             totalPackets[type] += loss.packetsTotal;
             lostPackets[type] += loss.packetsLost;
 
         }
 
         const now = this.currentAudioLevelsReport[idx];
+
         if (now.type != 'ssrc') {
             continue;
         }
 
         const before = this.baselineAudioLevelsReport[idx];
         const ssrc = getStatValue(now, 'ssrc');
+
         if (!before) {
             logger.warn(`${ssrc} not enough data`);
             continue;
         } catch(e) {/* not supported*/
             logger.warn('Audio Levels are not available in the statistics.');
             clearInterval(this.audioLevelsIntervalId);
+
             return;
         }
 

modules/statistics/statistics.js

 import analytics from './AnalyticsAdapter';
 const CallStats = require('./CallStats');
 const EventEmitter = require('events');
+
 import JitsiTrackError from '../../JitsiTrackError';
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 const LocalStats = require('./LocalStatsCollector.js');
 const RTPStats = require('./RTPStatsCollector.js');
 const ScriptUtil = require('../util/ScriptUtil');
+
 import * as StatisticsEvents from '../../service/statistics/Events';
 
 /**
     }
     const localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
         callback);
+
     this.localStats.push(localStats);
     localStats.start();
 };
     for(let i = 0; i < Statistics.localStats.length; i++) {
         if(Statistics.localStats[i].stream === stream) {
             const localStats = Statistics.localStats.splice(i, 1);
+
             localStats[0].stop();
             break;
         }
 Statistics.prototype.stopCallStats = function() {
     if(this.callStatsStarted) {
         const index = Statistics.callsStatsInstances.indexOf(this.callstats);
+
         if(index > -1) {
             Statistics.callsStatsInstances.splice(index, 1);
         }

modules/transcription/audioRecorder.js

     // Create a new stream which only holds the audio track
     const originalStream = trackRecorder.track.getOriginalStream();
     const stream = createEmptyStream();
+
     originalStream.getAudioTracks().forEach(track => stream.addTrack(track));
     // Create the MediaRecorder
     trackRecorder.recorder = new MediaRecorder(stream,
         // create the track recorder
         const trackRecorder = instantiateTrackRecorder(track);
         // push it to the local array of all recorders
+
         this.recorders.push(trackRecorder);
         // update the name of the trackRecorders
         this.updateNames();
 
     const array = this.recorders;
     let i;
+
     for(i = 0; i < array.length; i++) {
         if(array[i].track.getParticipantId() === track.getParticipantId()) {
             const recorderToRemove = array[i];
+
             if(this.isRecording) {
                 stopRecorder(recorderToRemove);
             } else {
  */
 audioRecorder.prototype.updateNames = function() {
     const conference = this.jitsiConference;
+
     this.recorders.forEach(trackRecorder => {
         if(trackRecorder.track.isLocal()) {
             trackRecorder.name = 'the transcriber';
             const id = trackRecorder.track.getParticipantId();
             const participant = conference.getParticipantById(id);
             const newName = participant.getDisplayName();
+
             if(newName !== 'undefined') {
                 trackRecorder.name = newName;
             }
  */
 audioRecorder.prototype.download = function() {
     const t = this;
+
     this.recorders.forEach(trackRecorder => {
         const blob = new Blob(trackRecorder.data, {type: t.fileType});
         const url = URL.createObjectURL(blob);
         const a = document.createElement('a');
+
         document.body.appendChild(a);
         a.style = 'display: none';
         a.href = url;
 
     const array = [];
     const t = this;
+
     this.recorders.forEach(
           recorder =>
               array.push(
                       new Blob(recorder.data, {type: t.fileType}),
                       recorder.name,
                       recorder.startTime)));
+
     return array;
 };
 

modules/transcription/transcriber.js

     const t = this;
 
     const callBack = blobCallBack.bind(this);
+
     this.audioRecorder.getRecordingResults().forEach(recordingResult => {
         t.transcriptionService.send(recordingResult, callBack);
         t.counter++;
         let offset = answer.startTime.getUTCMilliseconds()
             - this.startTime.getUTCMilliseconds();
         // transcriber time will always be earlier
+
         if (offset < 0) {
             offset = 0; // presume 0 if it somehow not earlier
         }
 
         let array = '[';
+
         answer.wordArray.forEach(wordObject => {
             wordObject.begin += offset;
             wordObject.end += offset;
     // arrays of Word objects
     const potentialWords = []; // array of the first Word objects
     // check if any arrays are already empty and remove them
+
     hasPopulatedArrays(arrays);
 
     // populate all the potential Words for a first time
     let lowestWordArray;
     let wordToAdd;
     let foundSmaller;
+
     while(hasPopulatedArrays(arrays)) {
         // first select the lowest array;
         lowestWordArray = arrays[0];
             twoDimensionalArray.splice(i, 1);
         }
     }
+
     return twoDimensionalArray.length > 0;
 };
 
     } else{
         if(array[array.length - 1].begin <= word.begin) {
             array.push(word);
+
             return;
         }
         let i;
+
         for(i = 0; i < array.length; i++) {
             if(word.begin < array[i].begin) {
                 array.splice(i, 0, word);
+
                 return;
             }
         }
                  FINISHED_STATE}" state. It's currently in the "${
                  this.state}" state`);
     }
+
     return this.transcription;
 };
 

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

  */
 TranscriptionService.prototype.send = function send(recordingResult, callback) {
     const t = this;
+
     this.sendRequest(recordingResult.blob, response => {
         if(t.verify(response)) {
             recordingResult.wordArray = t.formatResponse(response);

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

     console.log(`sending an audio file  to ${this.url}`);
     console.log(`the audio file being sent: ${audioFileBlob}`);
     const request = new XMLHttpRequest();
+
     request.onreadystatechange = function() {
         if(request.readyState === XMLHttpRequest.DONE
             && request.status === 200) {
     const result = JSON.parse(response).objects;
     // make sure to delete the session id object, which is always
     // the first value in the JSON array
+
     result.shift();
     const array = [];
+
     result.forEach(
         word =>
             word.filler
                 || array.push(new Word(word.word, word.start, word.end)));
+
     return array;
 };
 
     }
     // test if the string can be parsed into valid JSON
     let json;
+
     try{
         json = JSON.parse(response);
     } catch (error) {
         console.log(error);
+
         return false;
     }
     // check if the JSON has a "objects" value
     }
     // get the "objects" value and check for a session ID
     const array = json.objects;
+
     if(!(array[0] && array[0]['session-id'])) {
         return false;
     }
+
     // everything seems to be in order
     return true;
 };
  */
 function getURL() {
     const message = 'config does not contain an url to a Sphinx4 https server';
+
     if(config.sphinxURL === undefined) {
         console.log(message);
     } else {
         const toReturn = config.sphinxURL;
+
         if(toReturn.includes !== undefined && toReturn.includes('https://')) {
             return toReturn;
         }

modules/util/AuthUtil.js

      */
     getTokenAuthUrl(urlPattern, roomName, roleUpgrade) {
         const url = urlPattern;
+
         if (typeof url !== 'string') {
             return null;
         }
+
         return url.replace('{room}', roomName)
             .replace('{roleUpgrade}', roleUpgrade === true);
     }

modules/util/EventEmitterForwarder.js

 EventEmitterForwarder.prototype.forward = function(...args) {
     const srcEvent = args[0];
     // This will be the "this" value for emit function.
+
     args[0] = this.dest;
     // Using bind.apply to pass the arguments as Array-like object ("arguments")
     this.src.addListener(

modules/util/GlobalOnErrorHandler.js

      */
     callErrorHandler(error) {
         const errHandler = window.onerror;
+
         if(!errHandler) {
             return;
         }
      */
     callUnhandledRejectionHandler(error) {
         const errHandler = window.onunhandledrejection;
+
         if(!errHandler) {
             return;
         }

modules/util/RandomUtil.js

      */
     randomHexString(len) {
         let ret = '';
+
         while (len--) {
             ret += this.randomHexDigit();
         }
+
         return ret;
     },
     randomElement,

modules/util/ScriptUtil.js

             // finds the src url of the current loaded script
             // and use it as base of the src supplied argument
             const scriptEl = currentExecutingScript();
+
             if(scriptEl) {
                 const scriptSrc = scriptEl.src;
                 const baseScriptSrc
                     = scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);
+
                 if (scriptSrc && baseScriptSrc) {
                     src = baseScriptSrc + src;
                 }

modules/version/ComponentsVersions.js

     = function(node, mucResource, mucJid) {
         if (node.attributes.xmlns !== 'http://jitsi.org/jitmeet') {
             logger.warn('Ignored presence versions node - invalid xmlns', node);
+
             return;
         }
 
             logger.warn(
                 `Received versions not from the focus user: ${node}`,
                 mucJid);
+
             return;
         }
 
         const log = [];
+
         node.children.forEach(item => {
 
             const componentName = item.attributes.name;
+
             if (componentName !== ComponentsVersions.FOCUS_COMPONENT
             && componentName !== ComponentsVersions.XMPP_SERVER_COMPONENT
             && componentName !== ComponentsVersions.VIDEOBRIDGE_COMPONENT) {
                 logger.warn(
                     `Received version for not supported component name: ${
                         componentName}`);
+
                 return;
             }
 
             const version = item.value;
+
             if (this.versions[componentName] !== version) {
                 this.versions[componentName] = version;
                 logger.info(`Got ${componentName} version: ${version}`);

modules/xmpp/Caps.js

 
 function compareIdentities(a, b) {
     let res = 0;
+
     IDENTITY_PROPERTIES_FOR_COMPARE.some(key =>
         (res = ((a[key] > b[key]) && 1) || ((a[key] < b[key]) && -1)) !== 0
     );
+
     return res;
 }
 
         this.rooms = new Set();
 
         const emuc = connection.emuc;
+
         emuc.addListener(XMPPEvents.EMUC_ROOM_ADDED,
             room => this._addChatRoom(room));
         emuc.addListener(XMPPEvents.EMUC_ROOM_REMOVED,
     getFeatures(jid, timeout = 5000) {
         const user
             = jid in this.jidToVersion ? this.jidToVersion[jid] : null;
+
         if(!user || !(user.version in this.versionToCapabilities)) {
             const node = user ? `${user.node}#${user.version}` : null;
+
+
             return new Promise((resolve, reject) =>
                 this.disco.info(jid, node, response => {
                     const features = new Set();
-                    $(response).find('>query>feature').each((idx, el) =>
-                            features.add(el.getAttribute('var')));
+
+                    $(response)
+                        .find('>query>feature')
+                        .each(
+                            (idx, el) => features.add(el.getAttribute('var')));
                     if(user) {
                             // TODO: Maybe use the version + node + hash
                             // as keys?
                 }, reject , timeout)
             );
         }
+
         return Promise.resolve(this.versionToCapabilities[user.version]);
     }
 
     _generateVersion() {
         const identities = this.disco._identities.sort(compareIdentities);
         const features = this.disco._features.sort();
+
         this.version = b64_sha1(
             identities.reduce(
                     (accumulatedValue, identity) =>
         const version = caps.getAttribute('ver');
         const node = caps.getAttribute('node');
         const oldVersion = this.jidToVersion[from];
+
         this.jidToVersion[from] = {version, node};
         if(oldVersion && oldVersion.version !== version) {
             this.eventEmitter.emit(XMPPEvents.PARTCIPANT_FEATURES_CHANGED,
                 from);
         }
+
         // return true to not remove the handler from Strophe
         return true;
     }

modules/xmpp/ChatRoom.js

 const parser = {
     packet2JSON(packet, nodes) {
         const self = this;
+
+        // eslint-disable-next-line newline-per-chained-call
         $(packet).children().each(function() {
             const tagName = $(this).prop('tagName');
             const node = {
                 tagName
             };
+
             node.attributes = {};
             $($(this)[0].attributes).each((index, attr) => {
                 node.attributes[ attr.name ] = attr.value;
             });
             const text = Strophe.getText($(this)[0]);
+
             if (text) {
                 node.value = text;
             }
     json2packet(nodes, packet) {
         for(let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
+
             if(node) {
                 packet.c(node.tagName, node.attributes);
                 if(node.value) {
  */
 function filterNodeFromPresenceJSON(pres, nodeName) {
     const res = [];
+
     for(let i = 0; i < pres.length; i++) {
         if(pres[i].tagName === nodeName) {
             res.push(pres[i]);
     return res;
 }
 
+// XXX As ChatRoom constructs XMPP stanzas and Strophe is build around the idea
+// of chaining function calls, allow long function call chains.
+/* eslint-disable newline-per-chained-call */
+
 export default class ChatRoom extends Listenable {
     constructor(connection, jid, password, XMPP, options) {
         super();
 
     sendPresence(fromJoin) {
         const to = this.presMap.to;
+
         if (!to || (!this.joined && !fromJoin)) {
             // Too early to send presence - not initialized
             return;
     doLeave() {
         logger.log('do leave', this.myroomjid);
         const pres = $pres({to: this.myroomjid, type: 'unavailable' });
+
         this.presMap.length = 0;
 
         // XXX Strophe is asynchronously sending by default. Unfortunately, that
                 = $(result).find('>query>feature[var="muc_passwordprotected"]')
                         .length
                     === 1;
+
             if (locked != this.locked) {
                 this.eventEmitter.emit(XMPPEvents.MUC_LOCK_CHANGED, locked);
                 this.locked = locked;
                     '>query>x[xmlns="jabber:x:data"]'
                     + '>field[var="muc#roomconfig_whois"]').length) {
                 const errmsg = 'non-anonymous rooms not supported';
+
                 GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
                 logger.error(errmsg);
+
                 return;
             }
 
         const from = pres.getAttribute('from');
         // Parse roles.
         const member = {};
+
         member.show = $(pres).find('>show').text();
         member.status = $(pres).find('>status').text();
         const mucUserItem
-            = $(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>item');
+            = $(pres).find(
+                '>x[xmlns="http://jabber.org/protocol/muc#user"]>item');
+
         member.affiliation = mucUserItem.attr('affiliation');
         member.role = mucUserItem.attr('role');
 
         // Focus recognition
         const jid = mucUserItem.attr('jid');
+
         member.jid = jid;
         member.isFocus
             = jid && jid.indexOf(`${this.moderator.getFocusUserJid()}/`) === 0;
 
         $(pres).find('>x').remove();
         const nodes = [];
+
         parser.packet2JSON(pres, nodes);
         this.lastPresences[from] = nodes;
         let jibri = null;
         // process nodes to extract data needed for MUC_JOINED and
         // MUC_MEMBER_JOINED events
+
         for(let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
+
             switch(node.tagName) {
             case 'nick':
                 member.nick = node.value;
 
         if (from == this.myroomjid) {
             const newRole = member.affiliation == 'owner' ? member.role : 'none';
+
             if (this.role !== newRole) {
                 this.role = newRole;
                 this.eventEmitter.emit(XMPPEvents.LOCAL_ROLE_CHANGED, this.role);
                 this.joined = true;
                 const now = this.connectionTimes['muc.joined']
                     = window.performance.now();
+
                 logger.log('(TIME) MUC joined:\t', now);
 
                 // set correct initial state of locked
             // Presence update for existing participant
             // Watch role change:
             const memberOfThis = this.members[from];
+
             if (memberOfThis.role != member.role) {
                 memberOfThis.role = member.role;
                 this.eventEmitter.emit(
         // for the rest info we got in presence
         for(let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
+
             switch(node.tagName) {
             case 'nick':
                 if(!member.isFocus) {
                 break;
             case 'call-control': {
                 const att = node.attributes;
+
                 if(!att) {
                     break;
                 }
         // otherwise we can remove the presence handler from strophe
         try {
             let tagHandler = this.presHandlers[node.tagName];
+
             if (node.tagName.startsWith('jitsi_participant_')) {
                 tagHandler = this.participantPropertyListener;
             }
 
     sendMessage(body, nickname) {
         const msg = $msg({to: this.roomjid, type: 'groupchat'});
+
         msg.c('body', body).up();
         if (nickname) {
             msg.c('nick', {xmlns: 'http://jabber.org/protocol/nick'}).t(nickname).up().up();
 
     setSubject(subject) {
         const msg = $msg({to: this.roomjid, type: 'groupchat'});
+
         msg.c('subject', subject);
         this.connection.send(msg);
     }
             const reasonSelect = $(pres).find(
                     '>x[xmlns="http://jabber.org/protocol/muc#user"]'
                     + '>destroy>reason');
+
             if (reasonSelect.length) {
                 reason = reasonSelect.text();
             }
 
             this.eventEmitter.emit(XMPPEvents.MUC_DESTROYED, reason);
             this.connection.emuc.doLeave(this.roomjid);
+
             return true;
         }
 
                 '>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="307"]'
             ).length !== 0;
         const membersKeys = Object.keys(this.members);
+
         if (!isSelfPresence) {
             delete this.members[from];
             this.onParticipantLeft(from, false);
             // event.
             membersKeys.forEach(jid => {
                 const member = this.members[jid];
+
                 delete this.members[jid];
                 this.onParticipantLeft(jid, member.isFocus);
             });
 
         const txt = $(msg).find('>body').text();
         const type = msg.getAttribute('type');
+
         if (type == 'error') {
             this.eventEmitter.emit(XMPPEvents.CHAT_ERROR_RECEIVED,
                 $(msg).find('>text').text(), txt);
+
             return true;
         }
 
         const subject = $(msg).find('>subject');
+
         if (subject.length) {
             const subjectText = subject.text();
+
             if (subjectText || subjectText === '') {
                 this.eventEmitter.emit(XMPPEvents.SUBJECT_CHANGED, subjectText);
                 logger.log(`Subject is changed to ${subjectText}`);
             if (stamp) {
                 // the format is CCYYMMDDThh:mm:ss
                 const dateParts = stamp.match(/(\d{4})(\d{2})(\d{2}T\d{2}:\d{2}:\d{2})/);
+
                 stamp = `${dateParts[1]}-${dateParts[2]}-${dateParts[3]}Z`;
             }
         }
         } else if ($(pres).find(
             '>error[type="cancel"]>not-allowed[xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"]').length) {
             const toDomain = Strophe.getDomainFromJid(pres.getAttribute('to'));
+
             if (toDomain === this.xmpp.options.hosts.anonymousdomain) {
                 // enter the room by replying with 'not-authorized'. This would
                 // result in reconnection from authorized domain.
                     const formsubmit
                         = $iq({to: this.roomjid, type: 'set'})
                             .c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'});
+
                     formsubmit.c('x', {xmlns: 'jabber:x:data', type: 'submit'});
                     formsubmit.c('field', {'var': 'FORM_TYPE'}).c('value').t('http://jabber.org/protocol/muc#roomconfig').up().up();
                     formsubmit.c('field', {'var': 'muc#roomconfig_roomsecret'}).c('value').t(key).up().up();
 
     removeFromPresence(key) {
         const nodes = this.presMap.nodes.filter(node => key !== node.tagName);
+
         this.presMap.nodes = nodes;
     }
 
      */
     isFocus(mucJid) {
         const member = this.members[mucJid];
+
         if (member) {
             return member.isFocus;
         }
+
         return null;
     }
 
         if (this.members[peerJid]) {
             return this.members[peerJid].role;
         }
+
         return null;
     }
 
     getMediaPresenceInfo(endpointId, mediaType) {
         // Will figure out current muted status by looking up owner's presence
         const pres = this.lastPresences[`${this.roomjid}/${endpointId}`];
+
         if (!pres) {
             // No presence available
             return null;
             }
         } else {
             logger.error(`Unsupported media type: ${mediaType}`);
+
             return null;
         }
 
         if(this.recording) {
             return this.recording.isSupported();
         }
+
         return false;
     }
 
         if(this.moderator) {
             return this.moderator.isSipGatewayEnabled();
         }
+
         return false;
     }
 
 
     onMute(iq) {
         const from = iq.getAttribute('from');
+
         if (from !== this.focusMucJid) {
             logger.warn('Ignored mute from non focus peer');
+
             return false;
         }
         const mute = $(iq).find('mute');
+
         if (mute.length) {
             const doMuteAudio = mute.text() === 'true';
+
             this.eventEmitter.emit(XMPPEvents.AUDIO_MUTED_BY_FOCUS, doMuteAudio);
         }
+
         return true;
     }
 
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => onMucLeft(true), 5000);
             const eventEmitter = this.eventEmitter;
+
             function onMucLeft(doReject = false) {
                 eventEmitter.removeListener(XMPPEvents.MUC_LEFT, onMucLeft);
                 clearTimeout(timeout);
         });
     }
 }
+
+/* eslint-enable newline-per-chained-call */

modules/xmpp/JingleSession.js

             const errmsg
                 = `attempt to initiate on session ${this.sid}
                    in state ${this.state}`;
+
             logger.error(errmsg);
             throw new Error(errmsg);
         }

modules/xmpp/JingleSessionPC.js

 
 import {getLogger} from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
+
 import JingleSession from './JingleSession';
 const SDPDiffer = require('./SDPDiffer');
 const SDPUtil = require('./SDPUtil');
             }
             // XXX this is broken, candidate is not parsed.
             const candidate = ev.candidate;
+
             if (candidate) {
                 // Discard candidates of disabled protocols.
                 let protocol = candidate.protocol;
+
                 if (typeof protocol === 'string') {
                     protocol = protocol.toLowerCase();
                     if (protocol === 'tcp' || protocol === 'ssltcp') {
                 return;
             }
             const now = window.performance.now();
+
             this.room.connectionTimes[
                     `ice.state.${this.peerconnection.iceConnectionState}`]
                 = now;
 
     sendIceCandidate(candidate) {
         const localSDP = new SDP(this.peerconnection.localDescription.sdp);
+
         if (candidate && !this.lasticecandidate) {
             const ice
                 = SDPUtil.iceparams(
                     localSDP.media[candidate.sdpMLineIndex], localSDP.session);
             const jcand = SDPUtil.candidateToJingle(candidate.candidate);
+
             if (!(ice && jcand)) {
                 const errorMesssage = 'failed to get ice && jcand';
+
                 GlobalOnErrorHandler.callErrorHandler(new Error(errorMesssage));
                 logger.error(errorMesssage);
+
                 return;
             }
             ice.xmlns = 'urn:xmpp:jingle:transports:ice-udp:1';
                 sid: this.sid});
 
         const localSDP = new SDP(this.peerconnection.localDescription.sdp);
+
         for (let mid = 0; mid < localSDP.media.length; mid++) {
             const cands = candidates.filter(el => el.sdpMLineIndex == mid);
             const mline
                 = SDPUtil.parse_mline(localSDP.media[mid].split('\r\n')[0]);
+
             if (cands.length > 0) {
                 const ice
                     = SDPUtil.iceparams(localSDP.media[mid], localSDP.session);
+
                 ice.xmlns = 'urn:xmpp:jingle:transports:ice-udp:1';
                 cand.c('content', {
                     creator: this.initiator == this.localJid
                     const candidate
                         = SDPUtil.candidateToJingle(cands[i].candidate);
                     // Mangle ICE candidate if 'failICE' test option is enabled
+
                     if (this.failICE) {
                         candidate.ip = '1.1.1.1';
                     }
 
                 if (fingerprint_line) {
                     const tmp = SDPUtil.parse_fingerprint(fingerprint_line);
+
                     tmp.required = true;
                     cand.c(
                         'fingerprint',
                 = $(content).find(
                     'description>'
                         + 'source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
+
             ssrcs.each((idx, ssrcElement) => {
                 const ssrc = ssrcElement.getAttribute('ssrc');
+
                 $(ssrcElement)
                     .find('>ssrc-info[xmlns="http://jitsi.org/jitmeet"]')
                     .each((idx, ssrcInfoElement) => {
                         const owner = ssrcInfoElement.getAttribute('owner');
+
                         if (owner && owner.length) {
                             this.ssrcOwners[ssrc]
                                 = Strophe.getResourceFromJid(owner);
     setOfferCycle(jingleOfferIq, success, failure) {
         const workFunction = finishedCallback => {
             const newRemoteSdp = this._processNewJingleOfferIq(jingleOfferIq);
+
             this._renegotiate(newRemoteSdp)
                 .then(() => {
                     finishedCallback();
                     finishedCallback(error);
                 });
         };
+
         this.modificationQueue.push(
             workFunction,
             error => {
         // the SCTP connection established with the new bridge.
         this.room.eventEmitter.emit(XMPPEvents.ICE_RESTARTING);
         const originalOffer = jingleOfferElem.clone();
+
         jingleOfferElem.find('>content[name=\'data\']').remove();
 
         // First set an offer without the 'data' section
                     () => {
                         const localSDP
                             = new SDP(this.peerconnection.localDescription.sdp);
+
                         this.sendTransportAccept(localSDP, success, failure);
                     },
                     failure);
                 initiator: this.initiator,
                 responder: this.responder,
                 sid: this.sid });
+
         if (this.webrtcIceTcpDisable) {
             localSDP.removeTcpCandidates = true;
         }
 
         localSDP.media.forEach((medialines, idx) => {
             const mline = SDPUtil.parse_mline(medialines.split('\r\n')[0]);
+
             transportAccept.c('content',
                 {
                     creator:
             .c(reason || 'success');
 
         if (text) {
+            // eslint-disable-next-line newline-per-chained-call
             sessionTerminate.up().c('text').t(text);
         }
 
      */
     _parseSsrcInfoFromSourceAdd(sourceAddElem, currentRemoteSdp) {
         const addSsrcInfo = [];
+
         $(sourceAddElem).each((idx, content) => {
             const name = $(content).attr('name');
             let lines = '';
+
             $(content)
                 .find('ssrc-group[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]')
                 .each(function() {
                     const semantics = this.getAttribute('semantics');
-                    const ssrcs = $(this).find('>source').map(function() {
-                        return this.getAttribute('ssrc');
-                    }).get();
+                    const ssrcs
+                        = $(this)
+                            .find('>source')
+                            .map(function() {
+                                return this.getAttribute('ssrc');
+                            })
+                            .get();
 
                     if (ssrcs.length) {
                         lines
             const tmp
                 = $(content).find(
                     'source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
+
             tmp.each(function() {
                 const ssrc = $(this).attr('ssrc');
+
                 if (currentRemoteSdp.containsSSRC(ssrc)) {
                     logger.warn(
                         `Source-add request for existing SSRC: ${ssrc}`);
+
                     return;
                 }
+
+                // eslint-disable-next-line newline-per-chained-call
                 $(this).find('>parameter').each(function() {
                     lines += `a=ssrc:${ssrc} ${$(this).attr('name')}`;
                     if ($(this).attr('value') && $(this).attr('value').length) {
                 addSsrcInfo[idx] += lines;
             });
         });
+
         return addSsrcInfo;
     }
 
         if (!this.peerconnection.localDescription) {
             logger.warn('addSource - localDescription not ready yet');
             setTimeout(() => this.addRemoteStream(elem), 200);
+
             return;
         }
         logger.log('Processing add remote stream');
             const addSsrcInfo = this._parseSsrcInfoFromSourceAdd(elem, sdp);
 
             const newRemoteSdp = this._processRemoteAddSource(addSsrcInfo);
+
             this._renegotiate(newRemoteSdp)
                 .then(() => {
                     logger.info('Remote source-add processed');
                     const newSdp
                         = new SDP(this.peerconnection.localDescription.sdp);
+
                     logger.log('SDPs', mySdp, newSdp);
                     this.notifyMySSRCUpdate(mySdp, newSdp);
                     finishedCallback();
                     finishedCallback(error);
                 });
         };
+
         this.modificationQueue.push(workFunction);
     }
 
         if (!this.peerconnection.localDescription) {
             logger.warn('removeSource - localDescription not ready yet');
             setTimeout(() => this.removeRemoteStream(elem), 200);
+
             return;
         }
 
 
             const newRemoteSdp
                 = this._processRemoteRemoveSource(removeSsrcInfo);
+
             this._renegotiate(newRemoteSdp)
                 .then(() => {
                     logger.info('Remote source-remove processed');
                     const newSdp
                         = new SDP(this.peerconnection.localDescription.sdp);
+
                     logger.log('SDPs', mySdp, newSdp);
                     this.notifyMySSRCUpdate(mySdp, newSdp);
                     finishedCallback();
                     finishedCallback(error);
                 });
         };
+
         this.modificationQueue.push(workFunction);
     }
 
      */
     _processNewJingleOfferIq(offerIq) {
         const remoteSdp = new SDP('');
+
         if (this.webrtcIceTcpDisable) {
             remoteSdp.removeTcpCandidates = true;
         }
 
         remoteSdp.fromJingle(offerIq);
         this.readSsrcInfo($(offerIq).find('>content'));
+
         return remoteSdp;
     }
 
      */
     _processRemoteRemoveSource(removeSsrcInfo) {
         const remoteSdp = new SDP(this.peerconnection.remoteDescription.sdp);
+
         removeSsrcInfo.forEach((lines, idx) => {
             lines = lines.split('\r\n');
             lines.pop(); // remove empty last element;
      */
     _processRemoteAddSource(addSsrcInfo) {
         const remoteSdp = new SDP(this.peerconnection.remoteDescription.sdp);
+
         addSsrcInfo.forEach((lines, idx) => {
             remoteSdp.media[idx] += lines;
         });
         //  core flows like this.
         return new Promise((resolve, reject) => {
             const remoteUfrag = JingleSessionPC.getUfrag(remoteDescription.sdp);
+
             if (remoteUfrag != this.remoteUfrag) {
                 this.remoteUfrag = remoteUfrag;
                 this.room.eventEmitter.emit(
                 () => {
                     if (this.signalingState === 'closed') {
                         reject('Attempted to setRemoteDescription in state closed');
+
                         return;
                     }
                     logger.debug('Renegotiate: creating answer');
                         answer => {
                             const localUfrag
                                 = JingleSessionPC.getUfrag(answer.sdp);
+
                             if (localUfrag != this.localUfrag) {
                                 this.localUfrag = localUfrag;
                                 this.room.eventEmitter.emit(
                 // NOTE the code below assumes that no more than 1 video track
                 // can be added to the peer connection.
                 // Transition from no video to video (possibly screen sharing)
+
                 if (!oldTrack && newTrack && newTrack.isVideoTrack()) {
                     // Clearing current primary SSRC will make
                     // the SdpConsistency generate a new one which will result
                     .then(() => {
                         const newSdp
                             = new SDP(this.peerconnection.localDescription.sdp);
+
                         this.notifyMySSRCUpdate(oldSdp, newSdp);
                         finishedCallback();
                     }, error => {
                         finishedCallback(error);
                     });
             };
+
             this.modificationQueue.push(
                 workFunction,
                 error => {
         const actualStream
             = stream && stream.getOriginalStream
                 ? stream.getOriginalStream() : stream;
+
         if (this.peerconnection) {
             this.peerconnection.addStream(actualStream, ssrcInfo);
         }
      */
     _parseSsrcInfoFromSourceRemove(sourceRemoveElem, currentRemoteSdp) {
         const removeSsrcInfo = [];
+
         $(sourceRemoveElem).each((idx, content) => {
             const name = $(content).attr('name');
             let lines = '';
+
             $(content)
                 .find('ssrc-group[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]')
                 .each(function() {
                     const semantics = this.getAttribute('semantics');
-                    const ssrcs = $(this).find('>source').map(function() {
-                        return this.getAttribute('ssrc');
-                    }).get();
+                    const ssrcs
+                        = $(this)
+                            .find('>source')
+                            .map(function() {
+                                return this.getAttribute('ssrc');
+                            })
+                            .get();
 
                     if (ssrcs.length) {
                         lines
             const tmp
                 = $(content).find(
                     'source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
+
             tmp.each(function() {
                 const ssrc = $(this).attr('ssrc');
+
                 ssrcs.push(ssrc);
             });
             currentRemoteSdp.media.forEach((media, idx) => {
                 ssrcs.forEach(ssrc => {
                     const ssrcLines
                         = SDPUtil.find_lines(media, `a=ssrc:${ssrc}`);
+
                     if (ssrcLines.length) {
                         removeSsrcInfo[idx] += `${ssrcLines.join('\r\n')}\r\n`;
                     }
                 removeSsrcInfo[idx] += lines;
             });
         });
+
         return removeSsrcInfo;
     }
 
             if (!this.peerconnection) {
                 finishedCallback(
                     'Error: tried adding stream with no active peer connection');
+
                 return;
             }
             this.addStreamToPeerConnection(stream, ssrcInfo);
             }
             if (dontModifySources) {
                 finishedCallback();
+
                 return;
             }
             const oldSdp = new SDP(this.peerconnection.localDescription.sdp);
+
             this._renegotiate()
                 .then(() => {
                     const newSdp
                         = new SDP(this.peerconnection.localDescription.sdp);
                     // FIXME objects should not be logged
+
                     logger.log('SDPs', oldSdp, newSdp);
                     this.notifyMySSRCUpdate(oldSdp, newSdp);
                     finishedCallback();
                     finishedCallback(error);
                 });
         };
+
         this.modificationQueue.push(
             workFunction,
             error => {
         // of complications. Instead, we use the RTPSender and remove just
         // the track.
         let track = null;
+
         if (stream.getAudioTracks() && stream.getAudioTracks().length) {
             track = stream.getAudioTracks()[0];
         } else if (stream.getVideoTracks() && stream.getVideoTracks().length) {
 
         if (!track) {
             const msg = 'Cannot remove tracks: no tracks.';
+
             logger.log(msg);
+
             return;
         }
 
         this.peerconnection.peerconnection.getSenders().some(s => {
             if (s.track === track) {
                 sender = s;
+
                 return true;
             }
+
             return false;
         });
 
         const actualStream
             = stream && stream.getOriginalStream
                 ? stream.getOriginalStream() : stream;
+
         if (!this.peerconnection) {
             return;
         }
         const workFunction = finishedCallback => {
             if (!this.peerconnection) {
                 finishedCallback();
+
                 return;
             }
             if (RTCBrowserType.getBrowserType()
                 this.removeStreamFromPeerConnection(stream);
             }
             const oldSdp = new SDP(this.peerconnection.localDescription.sdp);
+
             this._renegotiate()
                 .then(() => {
                     const newSdp
                         = new SDP(this.peerconnection.localDescription.sdp);
+
                     if (ssrcInfo) {
                         this.modifiedSSRCs[ssrcInfo.type]
                             = this.modifiedSSRCs[ssrcInfo.type] || [];
                     finishedCallback(error);
                 });
         };
+
         this.modificationQueue.push(
             workFunction,
             error => {
 
         if (this.state !== JingleSessionState.ACTIVE) {
             logger.warn(`Skipping SSRC update in '${this.state} ' state.`);
+
             return;
         }
 
                 sid: this.sid
             }
             );
+
         sdpDiffer.toJingle(remove);
         const removed = this.fixJingle(remove);
 
 
             // Get XMPP error code and condition(reason)
             const errorElSel = $(errResponse).find('error');
+
             if (errorElSel.length) {
                 error.code = errorElSel.attr('code');
                 const errorReasonSel = $(errResponse).find('error :first');
+
                 if (errorReasonSel.length) {
                     error.reason = errorReasonSel[0].tagName;
                 }
      * @returns {boolean} true if the jingle has to be sent and false otherwise.
      */
     fixJingle(jingle) {
-        /* eslint-disable no-case-declarations */
+        // eslint-disable-next-line newline-per-chained-call
         const action = $(jingle.nodeTree).find('jingle').attr('action');
+
         switch (action) {
         case 'source-add':
         case 'session-accept':
         case 'source-remove':
             this.fixSourceRemoveJingle(jingle);
             break;
-        default:
+        default: {
             const errmsg = 'Unknown jingle action!';
+
             GlobalOnErrorHandler.callErrorHandler(errmsg);
             logger.error(errmsg);
+
             return false;
-        }/* eslint-enable no-case-declarations */
+        }
+        }
 
         const sources
             = $(jingle.tree()).find('>jingle>content>description>source');
+
+
         return sources && sources.length > 0;
     }
 
      */
     fixSourceAddJingle(jingle) {
         let ssrcs = this.modifiedSSRCs.unmute;
+
         this.modifiedSSRCs.unmute = [];
         if (ssrcs && ssrcs.length) {
             ssrcs.forEach(ssrcObj => {
                 const desc
                     = $(jingle.tree()).find(
                         `>jingle>content[name="${ssrcObj.mtype}"]>description`);
+
                 if (!desc || !desc.length) {
                     return;
                 }
                 ssrcObj.ssrcs.forEach(ssrc => {
                     const sourceNode = desc.find(`>source[ssrc="${ssrc}"]`);
+
                     sourceNode.remove();
                 });
                 ssrcObj.groups.forEach(group => {
                     const groupNode = desc.find(`>ssrc-group[semantics="${
                          group.semantics}"]:has(source[ssrc="${
                          group.ssrcs[0]}"])`);
+
                     groupNode.remove();
                 });
             });
                 const desc
                     = JingleSessionPC.createDescriptionNode(
                         jingle, ssrcObj.mtype);
+
+                // eslint-disable-next-line newline-per-chained-call
                 const cname = Math.random().toString(36).substring(2);
+
                 ssrcObj.ssrcs.forEach(ssrc => {
                     const sourceNode
                         = desc.find(`>source[ssrc="${ssrc}"]`);
+
                     sourceNode.remove();
                     const sourceXML
                         = '<source xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"'
                         + '<parameter xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"'
                         + ` value="${cname}" name="cname" />`
                         + '</source>';
+
                     desc.append(sourceXML);
                 });
                 ssrcObj.groups.forEach(group => {
                         = desc.find(
                             `>ssrc-group[semantics="${group.semantics
                                 }"]:has(source[ssrc="${group.ssrcs[0]}"])`);
+
                     groupNode.remove();
                     desc.append(
                         `<ssrc-group semantics="${group.semantics
      */
     fixSourceRemoveJingle(jingle) {
         let ssrcs = this.modifiedSSRCs.mute;
+
         this.modifiedSSRCs.mute = [];
         if (ssrcs && ssrcs.length) {
             ssrcs.forEach(ssrcObj => {
                         = $(jingle.tree()).find(
                             `>jingle>content[name="${ssrcObj.mtype
                                 }"]>description>source[ssrc="${ssrc}"]`);
+
                     sourceNode.remove();
                 });
                 ssrcObj.groups.forEach(group => {
                                 }"]>description>ssrc-group[semantics="${
                                 group.semantics}"]:has(source[ssrc="${
                                 group.ssrcs[0]}"])`);
+
                     groupNode.remove();
                 });
             });
                 const desc
                     = JingleSessionPC.createDescriptionNode(
                         jingle, ssrcObj.mtype);
+
                 ssrcObj.ssrcs.forEach(ssrc => {
                     const sourceNode
                         = desc.find(`>source[ssrc="${ssrc}"]`);
+
                     if (!sourceNode || !sourceNode.length) {
                         // Maybe we have to include cname, msid, etc here?
                         desc.append(
                         = desc.find(`>ssrc-group[semantics="${
                              group.semantics}"]:has(source[ssrc="${
                              group.ssrcs[0]}"])`);
+
                     if (!groupNode || !groupNode.length) {
                         desc.append(
                             `<ssrc-group semantics="${group.semantics
         let content = $(jingle.tree()).find(`>jingle>content[name="${mtype}"]`);
 
         if (!content || !content.length) {
-            $(jingle.tree()).find('>jingle').append(
-                `<content name="${mtype}"></content>`);
+            $(jingle.tree())
+                .find('>jingle')
+                .append(`<content name="${mtype}"></content>`);
             content = $(jingle.tree()).find(`>jingle>content[name="${mtype}"]`);
         }
 
         let desc = content.find('>description');
+
         if (!desc || !desc.length) {
             content.append(
                 `<description xmlns="urn:xmpp:jingle:apps:rtp:1" media="${
                     mtype}"></description>`);
             desc = content.find('>description');
         }
+
         return desc;
     }
 
     static getUfrag(sdp) {
         const ufragLines
             = sdp.split('\n').filter(line => line.startsWith('a=ice-ufrag:'));
+
         if (ufragLines.length > 0) {
             return ufragLines[0].substr('a=ice-ufrag:'.length);
         }

modules/xmpp/RtxModifier.js

     const primarySsrcCname = primarySsrcInfo.cname;
 
     const previousRtxSSRC = mLine.getRtxSSRC(primarySsrc);
+
     if (previousRtxSSRC === rtxSsrc) {
         logger.debug(`${rtxSsrc} was already associated with ${primarySsrc}`);
+
         return;
     }
     if (previousRtxSSRC) {
     modifyRtxSsrcs(sdpStr) {
         const sdpTransformer = new SdpTransformWrap(sdpStr);
         const videoMLine = sdpTransformer.selectMedia('video');
+
         if (!videoMLine) {
             logger.error(`No 'video' media found in the sdp: ${sdpStr}`);
+
             return sdpStr;
         }
         if (videoMLine.direction === 'inactive'
                 || videoMLine.direction === 'recvonly') {
             logger.debug('RtxModifier doing nothing, video '
                 + 'm line is inactive or recvonly');
+
             return sdpStr;
         }
         if (videoMLine.getSSRCCount() < 1) {
             logger.debug('RtxModifier doing nothing, no video ssrcs present');
+
             return sdpStr;
         }
         logger.debug('Current ssrc mapping: ', this.correspondingRtxSsrcs);
         const primaryVideoSsrcs = videoMLine.getPrimaryVideoSSRCs();
+
         logger.debug('Parsed primary video ssrcs ', primaryVideoSsrcs,
             ' making sure all have rtx streams');
         for (const ssrc of primaryVideoSsrcs) {
             const msid = videoMLine.getSSRCAttrValue(ssrc, 'msid');
             const cname = videoMLine.getSSRCAttrValue(ssrc, 'cname');
             let correspondingRtxSsrc = this.correspondingRtxSsrcs.get(ssrc);
+
             if (correspondingRtxSsrc) {
                 logger.debug(
                     'Already have an associated rtx ssrc for'
                 // If there's one in the sdp already for it, we'll just set
                 //  that as the corresponding one
                 const previousAssociatedRtxStream = videoMLine.getRtxSSRC(ssrc);
+
                 if (previousAssociatedRtxStream) {
                     logger.debug(
                         `Rtx stream ${previousAssociatedRtxStream} `
                 },
                 correspondingRtxSsrc);
         }
+
         return sdpTransformer.toRawSDP();
     }
 
     stripRtx(sdpStr) {
         const sdpTransformer = new SdpTransformWrap(sdpStr);
         const videoMLine = sdpTransformer.selectMedia('video');
+
         if (!videoMLine) {
             logger.error(`No 'video' media found in the sdp: ${sdpStr}`);
+
             return sdpStr;
         }
         if (videoMLine.direction === 'inactive'
                 || videoMLine.direction === 'recvonly') {
             logger.debug('RtxModifier doing nothing, video '
                 + 'm line is inactive or recvonly');
+
             return sdpStr;
         }
         if (videoMLine.getSSRCCount() < 1) {
             logger.debug('RtxModifier doing nothing, no video ssrcs present');
+
             return sdpStr;
         }
         if (!videoMLine.containsAnySSRCGroups()) {
             logger.debug('RtxModifier doing nothing, '
               + 'no video ssrcGroups present');
+
             return sdpStr;
         }
         const fidGroups = videoMLine.findGroups('FID');
         // Remove the fid groups from the mline
+
         videoMLine.removeGroupsBySemantics('FID');
         // Get the rtx ssrcs and remove them from the mline
         for (const fidGroup of fidGroups) {
             const rtxSsrc = parseSecondarySSRC(fidGroup);
+
             videoMLine.removeSSRC(rtxSsrc);
         }
 

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)
  */
 function getPrimaryVideoSsrc(parsedSdp) {
     const videoMLine = parsedSdp.media.find(m => m.type === 'video');
+
+
     return parseInt(SDPUtil.parsePrimaryVideoSsrc(videoMLine));
 }
 
  */
 function getPrimaryVideoSsrcs(parsedSdp) {
     const videoMLine = parsedSdp.media.find(m => m.type === 'video');
+
     if (numVideoSsrcs(parsedSdp) === 1) {
         return [videoMLine.ssrcs[0].id];
     }
     const simGroups = getVideoGroups(parsedSdp, 'SIM');
+
     if (simGroups.length > 1) {
         return;
     }
     const simGroup = simGroups[0];
+
+
     return SDPUtil.parseGroupSsrcs(simGroup);
 
 }
  */
 function getVideoGroups(parsedSdp, groupSemantics) {
     const videoMLine = parsedSdp.media.find(m => m.type === 'video');
+
     videoMLine.ssrcGroups = videoMLine.ssrcGroups || [];
+
     return videoMLine.ssrcGroups
     .filter(g => g.semantics === groupSemantics);
 }
                 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
                 expect(numVideoSsrcs(newSdp)).toEqual(2);
           // Should now have an FID group
                 const fidGroups = getVideoGroups(newSdp, 'FID');
+
                 expect(fidGroups.length).toEqual(1);
 
                 const fidGroup = fidGroups[0];
                 const fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
+
                 expect(fidGroupPrimarySsrc).toEqual(this.primaryVideoSsrc);
             });
 
                 newSdp = transform.parse(newSdpStr);
                 fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+
                 expect(newFidGroupRtxSsrc).toEqual(fidGroupRtxSsrc);
             });
 
 
                 let fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+
                 this.rtxModifier.clearSsrcCache();
 
           // Now pass the original sdp through again
                 newSdp = transform.parse(newSdpStr);
                 fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+
                 expect(newFidGroupRtxSsrc).not.toEqual(fidGroupRtxSsrc);
             });
 
           // -->The rtx ssrc used should be the one we set
                 const forcedRtxSsrc = 123456;
                 const ssrcCache = new Map();
+
                 ssrcCache.set(this.primaryVideoSsrc, forcedRtxSsrc);
                 this.rtxModifier.setSsrcCache(ssrcCache);
                 const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
 
                 const fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+
                 expect(fidGroupRtxSsrc).toEqual(forcedRtxSsrc);
             });
         });
                 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
                 expect(numVideoSsrcs(newSdp)).toEqual(this.primaryVideoSsrcs.length * 2);
           // Should now have FID groups
                 const fidGroups = getVideoGroups(newSdp, 'FID');
+
                 expect(fidGroups.length).toEqual(this.primaryVideoSsrcs.length);
                 fidGroups.forEach(fidGroup => {
                     const fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
+
                     expect(this.primaryVideoSsrcs.indexOf(fidGroupPrimarySsrc)).not.toEqual(-1);
                 });
             });
                 const rtxMapping = new Map();
                 let fidGroups = getVideoGroups(newSdp, 'FID');
           // Save the first mapping that is made
+
                 fidGroups.forEach(fidGroup => {
                     const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
                     const fidGroupPrimarySsrc = fidSsrcs[0];
                     const fidGroupRtxSsrc = fidSsrcs[1];
+
                     rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
                 });
           // Now pass the original sdp through again and make sure we get the same mapping
                     const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
                     const fidGroupPrimarySsrc = fidSsrcs[0];
                     const fidGroupRtxSsrc = fidSsrcs[1];
+
                     expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
                     expect(rtxMapping.get(fidGroupPrimarySsrc)).toEqual(fidGroupRtxSsrc);
                 });
                 const rtxMapping = new Map();
                 let fidGroups = getVideoGroups(newSdp, 'FID');
           // Save the first mapping that is made
+
                 fidGroups.forEach(fidGroup => {
                     const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
                     const fidGroupPrimarySsrc = fidSsrcs[0];
                     const fidGroupRtxSsrc = fidSsrcs[1];
+
                     rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
                 });
 
                     const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
                     const fidGroupPrimarySsrc = fidSsrcs[0];
                     const fidGroupRtxSsrc = fidSsrcs[1];
+
                     expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
                     expect(rtxMapping.get(fidGroupPrimarySsrc)).not.toEqual(fidGroupRtxSsrc);
                 });
           // Call modifyRtxSsrcs
           // -->The rtx ssrc used should be the one we set
                 const rtxMapping = new Map();
+
                 this.primaryVideoSsrcs.forEach(ssrc => {
                     rtxMapping.set(ssrc, SDPUtil.generateSsrc());
                 });
                 const newSdp = transform.parse(newSdpStr);
 
                 const fidGroups = getVideoGroups(newSdp, 'FID');
+
                 fidGroups.forEach(fidGroup => {
                     const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
                     const fidGroupPrimarySsrc = fidSsrcs[0];
                     const fidGroupRtxSsrc = fidSsrcs[1];
+
                     expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
                     expect(rtxMapping.get(fidGroupPrimarySsrc)).toEqual(fidGroupRtxSsrc);
                 });
             it('should handle a recvonly video mline', function() {
                 const sdp = SampleSdpStrings.plainVideoSdp;
                 const videoMLine = sdp.media.find(m => m.type === 'video');
+
                 videoMLine.direction = 'recvonly';
                 const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+
                 expect(newSdpStr).toEqual(this.transform.write(sdp));
             });
 
             it('should handle an inactive video mline', function() {
                 const sdp = SampleSdpStrings.plainVideoSdp;
                 const videoMLine = sdp.media.find(m => m.type === 'video');
+
                 videoMLine.direction = 'inactive';
                 const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+
                 expect(newSdpStr).toEqual(this.transform.write(sdp));
             });
 
             it('should handle a video mline with no video ssrcs', function() {
                 const sdp = SampleSdpStrings.plainVideoSdp;
                 const videoMLine = sdp.media.find(m => m.type === 'video');
+
                 videoMLine.ssrcs = [];
                 const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+
                 expect(newSdpStr).toEqual(this.transform.write(sdp));
             });
         });
             const newSdpStr = this.rtxModifier.stripRtx(sdpStr);
             const newSdp = transform.parse(newSdpStr);
             const fidGroups = getVideoGroups(newSdp, 'FID');
+
             expect(fidGroups.length).toEqual(0);
             expect(numVideoSsrcs(newSdp)).toEqual(1);
         });
         it('should do nothing to an sdp with no rtx', function() {
             const sdpStr = transform.write(SampleSdpStrings.plainVideoSdp);
             const newSdpStr = this.rtxModifier.stripRtx(sdpStr);
+
             expect(newSdpStr).toEqual(sdpStr);
         });
     });

modules/xmpp/SDP.js

 // SDP STUFF
 function SDP(sdp) {
     const media = sdp.split('\r\nm=');
+
     for (let i = 1, length = media.length; i < length; i++) {
         let media_i = `m=${media[i]}`;
+
         if (i != length - 1) {
             media_i += '\r\n';
         }
     const self = this;
     const media_ssrcs = {};
     let tmp;
+
     for (let mediaindex = 0; mediaindex < self.media.length; mediaindex++) {
         tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc:');
         const mid = SDPUtil.parse_mid(SDPUtil.find_line(self.media[mediaindex], 'a=mid:'));
             ssrcs: {},
             ssrcGroups: []
         };
+
         media_ssrcs[mediaindex] = media;
         tmp.forEach(line => {
             const linessrc = line.substring(7).split(' ')[0];
             // allocate new ChannelSsrc
+
             if(!media.ssrcs[linessrc]) {
                 media.ssrcs[linessrc] = {
                     ssrc: linessrc,
             const idx = line.indexOf(' ');
             const semantics = line.substr(0, idx).substr(13);
             const ssrcs = line.substr(14 + semantics.length).split(' ');
+
             if (ssrcs.length) {
                 media.ssrcGroups.push({
                     semantics,
             }
         });
     }
+
     return media_ssrcs;
 };
 /**
     // FIXME this code is really strange - improve it if you can
     const medias = this.getMediaSsrcMap();
     let result = false;
+
     Object.keys(medias).forEach(mediaindex => {
         if (result) {
             return;
             result = true;
         }
     });
+
     return result;
 };
 
 // remove iSAC and CN from SDP
 SDP.prototype.mangle = function() {
     let i, j, lines, mline, newdesc, rtpmap;
+
     for (i = 0; i < this.media.length; i++) {
         lines = this.media[i].split('\r\n');
         lines.pop(); // remove empty last element
 SDP.prototype.removeSessionLines = function(prefix) {
     const self = this;
     const lines = SDPUtil.find_lines(this.session, prefix);
+
     lines.forEach(line => {
         self.session = self.session.replace(`${line}\r\n`, '');
     });
     this.raw = this.session + this.media.join('');
+
     return lines;
 };
 // remove lines matching prefix from a media section specified by mediaindex
 SDP.prototype.removeMediaLines = function(mediaindex, prefix) {
     const self = this;
     const lines = SDPUtil.find_lines(this.media[mediaindex], prefix);
+
     lines.forEach(line => {
         self.media[mediaindex]
             = self.media[mediaindex].replace(`${line}\r\n`, '');
     });
     this.raw = this.session + this.media.join('');
+
     return lines;
 };
 
 SDP.prototype.toJingle = function(elem, thecreator) {
     let i, j, k, lines, mline, rtpmap, ssrc, tmp;
     // new bundle plan
+
     lines = SDPUtil.find_lines(this.session, 'a=group:');
     if (lines.length) {
         for (i = 0; i < lines.length; i++) {
             tmp = lines[i].split(' ');
             const semantics = tmp.shift().substr(8);
+
             elem.c('group', {xmlns: 'urn:xmpp:jingle:apps:grouping:0', semantics});
             for (j = 0; j < tmp.length; j++) {
                 elem.c('content', {name: tmp[j]}).up();
             continue; // eslint-disable-line no-continue
         }
         const assrcline = SDPUtil.find_line(this.media[i], 'a=ssrc:');
+
         if (assrcline) {
             ssrc = assrcline.substring(7).split(' ')[0]; // take the first
         } else {
 
         elem.c('content', {creator: thecreator, name: mline.media});
         const amidline = SDPUtil.find_line(this.media[i], 'a=mid:');
+
         if (amidline) {
             // prefer identifier from a=mid if present
             const mid = SDPUtil.parse_mid(amidline);
+
             elem.attrs({ name: mid });
         }
 
                 elem.c('payload-type', SDPUtil.parse_rtpmap(rtpmap));
                 // put any 'a=fmtp:' + mline.fmt[j] lines into <param name=foo value=bar/>
                 const afmtpline = SDPUtil.find_line(this.media[i], `a=fmtp:${mline.fmt[j]}`);
+
                 if (afmtpline) {
                     tmp = SDPUtil.parse_fmtp(afmtpline);
                     for (k = 0; k < tmp.length; k++) {
                 elem.up();
             }
             const crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
+
             if (crypto.length) {
                 elem.c('encryption', {required: 1});
                 crypto.forEach(
                 elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                 // FIXME: group by ssrc and support multiple different ssrcs
                 const ssrclines = SDPUtil.find_lines(this.media[i], 'a=ssrc:');
+
                 if(ssrclines.length > 0) {
                     ssrclines.forEach(line => {
                         const idx = line.indexOf(' ');
                         const linessrc = line.substr(0, idx).substr(7);
+
                         if (linessrc != ssrc) {
                             elem.up();
                             ssrc = linessrc;
                             elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                         }
                         const kv = line.substr(idx + 1);
+
                         elem.c('parameter');
                         if (kv.indexOf(':') == -1) {
                             elem.attrs({ name: kv });
                         } else {
                             const k = kv.split(':', 2)[0];
+
                             elem.attrs({ name: k });
 
                             let v = kv.split(':', 2)[1];
+
                             v = SDPUtil.filter_special_chars(v);
                             elem.attrs({ value: v });
                         }
                     elem.up();
                     elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                     elem.c('parameter');
-                    elem.attrs({name: 'cname', value:Math.random().toString(36).substring(7)});
+                    elem.attrs({
+                        name: 'cname',
+
+                        // eslint-disable-next-line newline-per-chained-call
+                        value: Math.random().toString(36).substring(7)
+                    });
                     elem.up();
                     // FIXME what case does this code handle ? remove ???
                     let msid = null;
                     // FIXME what is this ? global APP.RTC in SDP ?
                     const localTrack = APP.RTC.getLocalTracks(mline.media);
+
                     if (localTrack) {
                         // FIXME before this changes the track id was accessed,
                         // but msid stands for the stream id, makes no sense ?
 
                 // XEP-0339 handle ssrc-group attributes
                 const ssrc_group_lines = SDPUtil.find_lines(this.media[i], 'a=ssrc-group:');
+
                 ssrc_group_lines.forEach(line => {
                     const idx = line.indexOf(' ');
                     const semantics = line.substr(0, idx).substr(13);
                     const ssrcs = line.substr(14 + semantics.length).split(' ');
+
                     if (ssrcs.length) {
                         elem.c('ssrc-group', { semantics, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                         ssrcs.forEach(ssrc => elem.c('source', { ssrc }).up());
         elem.up(); // end of content
     }
     elem.up();
+
     return elem;
 };
 
 SDP.prototype.transportToJingle = function(mediaindex, elem) {
     let tmp;
     const self = this;
+
     elem.c('transport');
 
     // XEP-0343 DTLS/SCTP
     const sctpmap
         = SDPUtil.find_line(this.media[mediaindex], 'a=sctpmap:', self.session);
+
     if (sctpmap) {
         const sctpAttrs = SDPUtil.parse_sctpmap(sctpmap);
+
         elem.c('sctpmap', {
             xmlns: 'urn:xmpp:jingle:transports:dtls-sctp:1',
             number: sctpAttrs[0], /* SCTP port */
     // XEP-0320
     const fingerprints
         = SDPUtil.find_lines(this.media[mediaindex], 'a=fingerprint:', this.session);
+
     fingerprints.forEach(line => {
         tmp = SDPUtil.parse_fingerprint(line);
         tmp.xmlns = 'urn:xmpp:jingle:apps:dtls:0';
         // XEP-0176
         if (SDPUtil.find_line(this.media[mediaindex], 'a=candidate:', this.session)) { // add any a=candidate lines
             const lines = SDPUtil.find_lines(this.media[mediaindex], 'a=candidate:', this.session);
+
             lines.forEach(line => {
                 const candidate = SDPUtil.candidateToJingle(line);
+
                 if (self.failICE) {
                     candidate.ip = '1.1.1.1';
                 }
                 const protocol = candidate
                         && typeof candidate.protocol === 'string'
                     ? candidate.protocol.toLowerCase() : '';
+
                 if ((self.removeTcpCandidates
                         && (protocol === 'tcp' || protocol === 'ssltcp'))
                     || (self.removeUdpCandidates && protocol === 'udp')) {
 
 SDP.prototype.rtcpFbToJingle = function(mediaindex, elem, payloadtype) { // XEP-0293
     const lines = SDPUtil.find_lines(this.media[mediaindex], `a=rtcp-fb:${payloadtype}`);
+
     lines.forEach(line => {
         const tmp = SDPUtil.parse_rtcpfb(line);
+
         if (tmp.type == 'trr-int') {
             elem.c('rtcp-fb-trr-int', {xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0', value: tmp.params[0]});
             elem.up();
 SDP.prototype.rtcpFbFromJingle = function(elem, payloadtype) { // XEP-0293
     let media = '';
     let tmp = elem.find('>rtcp-fb-trr-int[xmlns="urn:xmpp:jingle:apps:rtp:rtcp-fb:0"]');
+
     if (tmp.length) {
         media += 'a=rtcp-fb:' + '*' + ' ' + 'trr-int' + ' ';
         if (tmp.attr('value')) {
         }
         media += '\r\n';
     });
+
     return media;
 };
 
 // construct an SDP from a jingle stanza
 SDP.prototype.fromJingle = function(jingle) {
     const self = this;
+
     this.raw = 'v=0\r\n'
         + 'o=- 1923518516 2 IN IP4 0.0.0.0\r\n'// FIXME
         + 's=-\r\n'
         + 't=0 0\r\n';
+
     // http://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-04#section-8
-    if ($(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]').length) {
-        $(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]').each((idx, group) => {
-            const contents = $(group).find('>content').map((idx, content) => content.getAttribute('name')).get();
+    const groups
+        = $(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]');
+
+    if (groups.length) {
+        groups.each((idx, group) => {
+            const contents
+                = $(group)
+                    .find('>content')
+                    .map((idx, content) => content.getAttribute('name'))
+                    .get();
+
             if (contents.length > 0) {
-                self.raw += `a=group:${group.getAttribute('semantics') || group.getAttribute('type')} ${contents.join(' ')}\r\n`;
+                self.raw
+                    += `a=group:${group.getAttribute('semantics') || group.getAttribute('type')} ${contents.join(' ')}\r\n`;
             }
         });
     }
     this.session = this.raw;
     jingle.find('>content').each(function() {
         const m = self.jingle2media($(this));
+
         self.media.push(m);
     });
 
         '>transport>sctpmap[xmlns="urn:xmpp:jingle:transports:dtls-sctp:1"]');
 
     let tmp = { media: desc.attr('media') };
+
     tmp.port = '1';
     if (content.attr('senders') == 'rejected') {
         // estos hack to reject an m-line.
         media += `a=sctpmap:${sctp.attr('number')} ${sctp.attr('protocol')}`;
 
         const streamCount = sctp.attr('streams');
+
         if (streamCount) {
             media += ` ${streamCount}\r\n`;
         } else {
             media += '\r\n';
         }
     } else {
-        tmp.fmt = desc.find('payload-type').map(
-            function() {
-                return this.getAttribute('id');
-            }).get();
+        tmp.fmt
+            = desc
+                .find('payload-type')
+                .map(function() {
+                    return this.getAttribute('id');
+                })
+                .get();
         media += `${SDPUtil.build_mline(tmp)}\r\n`;
     }
 
         media += `${SDPUtil.build_rtpmap(this)}\r\n`;
         if ($(this).find('>parameter').length) {
             media += `a=fmtp:${this.getAttribute('id')} `;
-            media += $(this).find('parameter').map(function() {
-                return (this.getAttribute('name')
-                        ? `${this.getAttribute('name')}=` : '')
-                    + this.getAttribute('value');
-            }).get().join('; ');
+            media
+                += $(this)
+                    .find('parameter')
+                    .map(function() {
+                        return (this.getAttribute('name')
+                                ? `${this.getAttribute('name')}=` : '')
+                            + this.getAttribute('value');
+                    })
+                    .get()
+                    .join('; ');
             media += '\r\n';
         }
         // xep-0293
 
     content.find('>transport[xmlns="urn:xmpp:jingle:transports:ice-udp:1"]>candidate').each(function() {
         let protocol = this.getAttribute('protocol');
+
         protocol = typeof protocol === 'string' ? protocol.toLowerCase() : '';
 
         if ((self.removeTcpCandidates
     // XEP-0339 handle ssrc-group attributes
     content.find('description>ssrc-group[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]').each(function() {
         const semantics = this.getAttribute('semantics');
-        const ssrcs = $(this).find('>source').map(function() {
-            return this.getAttribute('ssrc');
-        }).get();
+        const ssrcs
+            = $(this)
+                .find('>source')
+                .map(function() {
+                    return this.getAttribute('ssrc');
+                })
+                .get();
 
         if (ssrcs.length) {
             media += `a=ssrc-group:${semantics} ${ssrcs.join(' ')}\r\n`;
     tmp = content.find('description>source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
     tmp.each(function() {
         const ssrc = this.getAttribute('ssrc');
+
+        // eslint-disable-next-line newline-per-chained-call
         $(this).find('>parameter').each(function() {
             const name = this.getAttribute('name');
             let value = this.getAttribute('value');
+
             value = SDPUtil.filter_special_chars(value);
             media += `a=ssrc:${ssrc} ${name}`;
             if (value && value.length) {

modules/xmpp/SDPDiffer.js

                 return false;
             }
         }
+
         return true;
     }
 
     const myMedias = this.mySDP.getMediaSsrcMap();
     const othersMedias = this.otherSDP.getMediaSsrcMap();
     const newMedia = {};
+
     Object.keys(othersMedias).forEach(othersMediaIdx => {
         const myMedia = myMedias[othersMediaIdx];
         const othersMedia = othersMedias[othersMediaIdx];
+
         if(!myMedia && othersMedia) {
             // Add whole channel
             newMedia[othersMediaIdx] = othersMedia;
+
             return;
         }
         // Look for new ssrcs across the channel
 
             // try to match the other ssrc-group with an ssrc-group of ours
             let matched = false;
+
             for (let i = 0; i < myMedia.ssrcGroups.length; i++) {
                 const mySsrcGroup = myMedia.ssrcGroups[i];
+
                 if (otherSsrcGroup.semantics == mySsrcGroup.semantics
                     && arrayEquals.apply(otherSsrcGroup.ssrcs,
                                       [mySsrcGroup.ssrcs])) {
             }
         });
     });
+
     return newMedia;
 };
 
     const sdpMediaSsrcs = this.getNewMedia();
 
     let modified = false;
+
     Object.keys(sdpMediaSsrcs).forEach(mediaindex => {
         modified = true;
         const media = sdpMediaSsrcs[mediaindex];
+
         modify.c('content', {name: media.mid});
 
         modify.c('description',
         // generate sources from lines
         Object.keys(media.ssrcs).forEach(ssrcNum => {
             const mediaSsrc = media.ssrcs[ssrcNum];
+
             modify.c('source', { xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
             modify.attrs({ssrc: mediaSsrc.ssrc});
             // iterate over ssrc lines
             mediaSsrc.lines.forEach(line => {
                 const idx = line.indexOf(' ');
                 const kv = line.substr(idx + 1);
+
                 modify.c('parameter');
                 if (kv.indexOf(':') == -1) {
                     modify.attrs({ name: kv });
                     const nv = kv.split(':', 2);
                     const name = nv[0];
                     const value = SDPUtil.filter_special_chars(nv[1]);
+
                     modify.attrs({ name });
                     modify.attrs({ value });
                 }

modules/xmpp/SDPUtil.js

 import {getLogger} from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
+
 import RandomUtil from '../util/RandomUtil';
 const RTCBrowserType = require('../RTC/RTCBrowserType');
 
     iceparams(mediadesc, sessiondesc) {
         let data = null;
         let pwd, ufrag;
+
         if ((ufrag = SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc))
                 && (pwd = SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc))) {
             data = {
                 pwd: SDPUtil.parse_icepwd(pwd)
             };
         }
+
         return data;
     },
     parse_iceufrag(line) {
             parts.pop();
         }
         data.fmt = parts;
+
         return data;
     },
     build_mline(mline) {
         data.name = parts.shift();
         data.clockrate = parts.shift();
         data.channels = parts.length ? parts.shift() : '1';
+
         return data;
     },
     /**
         const protocol = parts[1];
         // Stream count is optional
         const streamCount = parts.length > 2 ? parts[2] : null;
+
+
         return [sctpPort, protocol, streamCount];// SCTP port
     },
     build_rtpmap(el) {
         let line = `a=rtpmap:${el.getAttribute('id')} ${el.getAttribute('name')}/${el.getAttribute('clockrate')}`;
+
         if (el.getAttribute('channels') && el.getAttribute('channels') != '1') {
             line += `/${el.getAttribute('channels')}`;
         }
+
         return line;
     },
     parse_crypto(line) {
         if (parts.length) {
             data['session-params'] = parts.join(' ');
         }
+
         return data;
     },
     parse_fingerprint(line) { // RFC 4572
 
         data.hash = parts.shift();
         data.fingerprint = parts.shift();
+
         // TODO assert that fingerprint satisfies 2UHEX *(":" 2UHEX) ?
         return data;
     },
         parts = parts.join(' ').split(';');
         for (let i = 0; i < parts.length; i++) {
             let key = parts[i].split('=')[0];
+
             while (key.length && key[0] == ' ') {
                 key = key.substring(1);
             }
             const value = parts[i].split('=')[1];
+
             if (key && value) {
                 data.push({name: key, value});
             } else if (key) {
                 data.push({name: '', value: key});
             }
         }
+
         return data;
     },
     parse_icecandidate(line) {
             }
         }
         candidate.network = '1';
-        candidate.id = Math.random().toString(36).substr(2, 10); // not applicable to SDP -- FIXME: should be unique, not just random
+
+        // not applicable to SDP -- FIXME: should be unique, not just random
+        // eslint-disable-next-line newline-per-chained-call
+        candidate.id = Math.random().toString(36).substr(2, 10);
+
         return candidate;
     },
     build_icecandidate(cand) {
         let line = [`a=candidate:${cand.foundation}`, cand.component, cand.protocol, cand.priority, cand.ip, cand.port, 'typ', cand.type].join(' ');
+
         line += ' ';
         switch (cand.type) {
         case 'srflx':
         line += 'generation';
         line += ' ';
         line += cand.hasOwnAttribute('generation') ? cand.generation : '0';
+
         return line;
     },
     parse_ssrc(desc) {
         for (let i = 0; i < lines.length; i++) {
             if (lines[i].substring(0, 7) == 'a=ssrc:') {
                 const idx = lines[i].indexOf(' ');
+
                 data[lines[i].substr(idx + 1).split(':', 2)[0]] = lines[i].substr(idx + 1).split(':', 2)[1];
             }
         }
+
         return data;
     },
     parse_rtcpfb(line) {
         const parts = line.substr(10).split(' ');
         const data = {};
+
         data.pt = parts.shift();
         data.type = parts.shift();
         data.params = parts;
+
         return data;
     },
     parse_extmap(line) {
         const parts = line.substr(9).split(' ');
         const data = {};
+
         data.value = parts.shift();
         if (data.value.indexOf('/') === -1) {
             data.direction = 'both';
         }
         data.uri = parts.shift();
         data.params = parts;
+
         return data;
     },
     find_line(haystack, needle, sessionpart) {
         let lines = haystack.split('\r\n');
+
         for (let i = 0; i < lines.length; i++) {
             if (lines[i].substring(0, needle.length) == needle) {
                 return lines[i];
                 return lines[j];
             }
         }
+
         return false;
     },
     find_lines(haystack, needle, sessionpart) {
                 needles.push(lines[j]);
             }
         }
+
         return needles;
     },
     candidateToJingle(line) {
         } else if (line.substring(0, 12) != 'a=candidate:') {
             logger.log('parseCandidate called with a line that is not a candidate line');
             logger.log(line);
+
             return null;
         }
         if (line.substring(line.length - 2) == '\r\n') {// chomp it
         if (elems[6] != 'typ') {
             logger.log('did not find typ in the right place');
             logger.log(line);
+
             return null;
         }
         candidate.foundation = elems[0].substring(12);
             }
         }
         candidate.network = '1';
-        candidate.id = Math.random().toString(36).substr(2, 10); // not applicable to SDP -- FIXME: should be unique, not just random
+
+        // not applicable to SDP -- FIXME: should be unique, not just random
+        // eslint-disable-next-line newline-per-chained-call
+        candidate.id = Math.random().toString(36).substr(2, 10);
+
         return candidate;
     },
     candidateFromJingle(cand) {
         let line = 'a=candidate:';
+
         line += cand.getAttribute('foundation');
         line += ' ';
         line += cand.getAttribute('component');
 
         let protocol = cand.getAttribute('protocol');
         // use tcp candidates for FF
+
         if (RTCBrowserType.isFirefox() && protocol.toLowerCase() == 'ssltcp') {
             protocol = 'tcp';
         }
         line += 'generation';
         line += ' ';
         line += cand.getAttribute('generation') || '0';
+
         return `${line}\r\n`;
     },
 
             .length;
         const numGroups
             = (videoMLine.ssrcGroups && videoMLine.ssrcGroups.length) || 0;
+
         if (numSsrcs > 1 && numGroups === 0) {
             // Ambiguous, can't figure out the primary
             return;
         }
         let primarySsrc = null;
+
         if (numSsrcs === 1) {
             primarySsrc = videoMLine.ssrcs[0].id;
         } else if (numSsrcs === 2) {
             const fidGroup
                 = videoMLine.ssrcGroups.find(
                     group => group.semantics === 'FID');
+
             if (fidGroup) {
                 primarySsrc = fidGroup.ssrcs.split(' ')[0];
             }
             const simGroup
                 = videoMLine.ssrcGroups.find(
                     group => group.semantics === 'SIM');
+
             if (simGroup) {
                 primarySsrc = simGroup.ssrcs.split(' ')[0];
             }
         }
+
         return primarySsrc;
     },
 
     getSsrcAttribute(mLine, ssrc, attributeName) {
         for (let i = 0; i < mLine.ssrcs.length; ++i) {
             const ssrcLine = mLine.ssrcs[i];
+
             if (ssrcLine.id === ssrc
                 && ssrcLine.attribute === attributeName) {
                 return ssrcLine.value;
      */
     preferVideoCodec(videoMLine, codecName) {
         let payloadType = null;
+
         for (let i = 0; i < videoMLine.rtp.length; ++i) {
             const rtp = videoMLine.rtp[i];
+
             if (rtp.codec === codecName) {
                 payloadType = rtp.payload;
                 break;
         if (payloadType) {
             const payloadTypes = videoMLine.payloads.split(' ').map(p => parseInt(p));
             const payloadIndex = payloadTypes.indexOf(payloadType);
+
             payloadTypes.splice(payloadIndex, 1);
             payloadTypes.unshift(payloadType);
             videoMLine.payloads = payloadTypes.join(' ');

modules/xmpp/SDPUtil.spec.js

         it('should move a preferred codec to the front', () => {
             const sdp = SampleSdpStrings.multiCodecVideoSdp;
             const videoMLine = sdp.media.find(m => m.type === 'video');
+
             SDPUtil.preferVideoCodec(videoMLine, 'H264');
             const newPayloadTypesOrder
                 = videoMLine.payloads.split(' ').map(ptStr => parseInt(ptStr));
+
             expect(newPayloadTypesOrder[0]).toEqual(126);
         });
     });

modules/xmpp/SdpConsistency.js

     makeVideoPrimarySsrcsConsistent(sdpStr) {
         const sdpTransformer = new SdpTransformWrap(sdpStr);
         const videoMLine = sdpTransformer.selectMedia('video');
+
         if (!videoMLine) {
             logger.error(`No 'video' media found in the sdp: ${sdpStr}`);
+
             return sdpStr;
         }
         if (videoMLine.direction === 'inactive') {
             logger.info(
                 'Sdp-consistency doing nothing, video mline is inactive');
+
             return sdpStr;
         }
         if (videoMLine.direction === 'recvonly') {
             }
         } else {
             const newPrimarySsrc = videoMLine.getPrimaryVideoSsrc();
+
             if (!newPrimarySsrc) {
                 logger.info('Sdp-consistency couldn\'t parse new primary ssrc');
+
                 return sdpStr;
             }
             if (this.cachedPrimarySsrc) {
                     if (group.semantics === 'FID') {
                         const primarySsrc = parsePrimarySSRC(group);
                         const rtxSsrc = parseSecondarySSRC(group);
+
                         if (primarySsrc === newPrimarySsrc) {
                             group.ssrcs
                                 = `${this.cachedPrimarySsrc} ${rtxSsrc}`;
                         this.cachedPrimarySsrc}`);
             }
         }
+
         return sdpTransformer.toRawSDP();
     }
 }

modules/xmpp/SdpTransformUtil.js

     if (!mLine.ssrcs) {
         return 0;
     }
+
     return mLine.ssrcs
             .map(ssrcInfo => ssrcInfo.id)
             .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
     selectMedia(mediaType) {
         const selectedMLine
             = this.parsedSDP.media.find(mLine => mLine.type === mediaType);
+
+
         return selectedMLine ? new MLineWrap(selectedMLine) : null;
     }
 
         if (!this.mLine.ssrcs) {
             this.mLine.ssrcs = [];
         }
+
         return this.mLine.ssrcs;
     }
 
         if (!this.mLine.ssrcGroups) {
             this.mLine.ssrcGroups = [];
         }
+
         return this.mLine.ssrcGroups;
     }
 
         const attribute = this._ssrcs.find(
             ssrcObj => ssrcObj.id == ssrcNumber
             && ssrcObj.attribute === attrName);
+
+
         return attribute && attribute.value;
     }
 
         }
 
         const numSsrcs = _getSSRCCount(this.mLine);
+
         if (numSsrcs === 1) {
             // Not using _ssrcs on purpose here
             return this.mLine.ssrcs[0].id;
             // Look for a SIM or FID group
         if (this.mLine.ssrcGroups) {
             const simGroup = this.findGroup('SIM');
+
             if (simGroup) {
                 return parsePrimarySSRC(simGroup);
             }
             const fidGroup = this.findGroup('FID');
+
             if (fidGroup) {
                 return parsePrimarySSRC(fidGroup);
             }
      */
     getRtxSSRC(primarySsrc) {
         const fidGroup = this.findGroupByPrimarySSRC('FID', primarySsrc);
+
+
         return fidGroup && parseSecondarySSRC(fidGroup);
     }
 
             if (ssrcGroupInfo.semantics === 'FID') {
                 // secondary FID streams should be filtered out
                 const secondarySsrc = parseSecondarySSRC(ssrcGroupInfo);
+
                 videoSSRCs.splice(
                     videoSSRCs.indexOf(secondarySsrc), 1);
             }
         }
+
         return videoSSRCs;
     }
 

modules/xmpp/moderator.js

 const AuthenticationEvents
     = require('../../service/authentication/AuthenticationEvents');
 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
+
 import Settings from '../settings/Settings';
 
 function createExpBackoffTimer(step) {
     let count = 1;
+
+
     return function(reset) {
         // Reset call
         if (reset) {
             count = 1;
+
             return;
         }
         // Calculate next timeout
         const timeout = Math.pow(2, count - 1);
+
         count += 1;
+
         return timeout * step;
     };
 }
                 logger.warn(
                     `Ignoring sessionId from different origin: ${
                         event.origin}`);
+
                 return;
             }
             Settings.setSessionId(event.data.sessionId);
 Moderator.prototype.onMucMemberLeft = function(jid) {
     logger.info(`Someone left is it focus ? ${jid}`);
     const resource = Strophe.getResourceFromJid(jid);
+
     if (resource === 'focus') {
         logger.info(
             'Focus has left the room - leaving conference');
     // Get focus component address
     let focusComponent = this.options.connection.hosts.focus;
     // If not specified use default:  'focus.domain'
+
     if (!focusComponent) {
         focusComponent = `focus.${this.options.connection.hosts.domain}`;
     }
+
     return focusComponent;
 };
 
             }).up();
     }
     elem.up();
+
     return elem;
 };
 
 
 Moderator.prototype.parseSessionId = function(resultIq) {
+    // eslint-disable-next-line newline-per-chained-call
     const sessionId = $(resultIq).find('conference').attr('session-id');
+
     if (sessionId) {
         logger.info(`Received sessionId:  ${sessionId}`);
         Settings.setSessionId(sessionId);
 };
 
 Moderator.prototype.parseConfigOptions = function(resultIq) {
-
-    this.setFocusUserJid(
-        $(resultIq).find('conference').attr('focusjid'));
+    // eslint-disable-next-line newline-per-chained-call
+    this.setFocusUserJid($(resultIq).find('conference').attr('focusjid'));
 
     const authenticationEnabled
         = $(resultIq).find(
         this.parseSessionId(resultIq);
     }
 
+    // eslint-disable-next-line newline-per-chained-call
     const authIdentity = $(resultIq).find('>conference').attr('identity');
 
     this.eventEmitter.emit(AuthenticationEvents.IDENTITY_UPDATED,
     // If the session is invalid, remove and try again without session ID to get
     // a new one
     const invalidSession = $(error).find('>error>session-invalid').length;
+
     if (invalidSession) {
         logger.info('Session expired! - removing');
         Settings.clearSessionId();
     }
     if ($(error).find('>error>graceful-shutdown').length) {
         this.eventEmitter.emit(XMPPEvents.GRACEFUL_SHUTDOWN);
+
         return;
     }
     // Check for error returned by the reservation system
     const reservationErr = $(error).find('>error>reservation-error');
+
     if (reservationErr.length) {
         // Trigger error event
         const errorCode = reservationErr.attr('error-code');
         const errorTextNode = $(error).find('>error>text');
         let errorMsg;
+
         if (errorTextNode) {
             errorMsg = errorTextNode.text();
         }
         this.eventEmitter.emit(
                 XMPPEvents.RESERVATION_ERROR, errorCode, errorMsg);
+
         return;
     }
     // Not authorized to create new room
     if ($(error).find('>error>not-authorized').length) {
         logger.warn('Unauthorized to start the conference', error);
         const toDomain = Strophe.getDomainFromJid(error.getAttribute('to'));
+
         if (toDomain !== this.options.connection.hosts.anonymousdomain) {
             // FIXME "is external" should come either from the focus or
             // config.js
             this.externalAuthEnabled = true;
         }
         this.eventEmitter.emit(XMPPEvents.AUTHENTICATION_REQUIRED);
+
         return;
     }
     const waitMs = this.getNextErrorTimeout();
     const errmsg = `Focus error, retry after ${waitMs}`;
+
     GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
     logger.error(errmsg, error);
     // Show message
     const retrySec = waitMs / 1000;
     // FIXME: message is duplicated ? Do not show in case of session invalid
     // which means just a retry
+
     if (!invalidSession) {
         this.eventEmitter.emit(
                 XMPPEvents.FOCUS_DISCONNECTED, focusComponent, retrySec);
 
     // Reset the error timeout (because we haven't failed here).
     this.getNextErrorTimeout(true);
+    // eslint-disable-next-line newline-per-chained-call
     if ('true' === $(result).find('conference').attr('ready')) {
         // Reset the non-error timeout (because we've succeeded here).
         this.getNextTimeout(true);
         callback();
     } else {
         const waitMs = this.getNextTimeout();
+
         logger.info(`Waiting for the focus... ${waitMs}`);
         window.setTimeout(() => this.allocateConferenceFocus(callback),
             waitMs);
                 this.parseSessionId(result);
                 resolve();
             }, error => {
+                // eslint-disable-next-line newline-per-chained-call
                 const code = $(error).find('>error').attr('code');
+
                 reject(error, code);
             }
         );
         'machine-uid': Settings.getMachineId()
     };
     let str = 'auth url'; // for logger
+
     if (popup) {
         attrs.popup = true;
         str = `POPUP ${str}`;
     this.connection.sendIQ(
         iq,
         result => {
+            // eslint-disable-next-line newline-per-chained-call
             let url = $(result).find('login-url').attr('url');
+
             url = decodeURIComponent(url);
             if (url) {
                 logger.info(`Got ${str}: ${url}`);
 Moderator.prototype.logout = function(callback) {
     const iq = $iq({to: this.getFocusComponent(), type: 'set'});
     const sessionId = Settings.getSessionId();
+
     if (!sessionId) {
         callback();
+
         return;
     }
     iq.c('logout', {
     this.connection.sendIQ(
         iq,
         result => {
+            // eslint-disable-next-line newline-per-chained-call
             let logoutUrl = $(result).find('logout').attr('logout-url');
+
             if (logoutUrl) {
                 logoutUrl = decodeURIComponent(logoutUrl);
             }
         },
         error => {
             const errmsg = 'Logout error';
+
             GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
             logger.error(errmsg, error);
         }

modules/xmpp/recording.js

 
 Recording.prototype.handleJibriPresence = function(jibri) {
     const attributes = jibri.attributes;
+
     if(!attributes) {
         return;
     }
 
     const newState = attributes.status;
+
     logger.log('Handle jibri presence : ', newState);
 
     if (newState === this.state) {
         options = options || {};
 
     // FIXME jibri does not accept IQ without 'url' attribute set ?
-        const iq = $iq({to: this.focusMucJid, type: 'set'})
-        .c('jibri', {
-            'xmlns': 'http://jitsi.org/protocol/jibri',
-            'action': state === Recording.status.ON
-                    ? Recording.action.START
-                    : Recording.action.STOP,
-            'streamid': options.streamId,
-        }).up();
+        const iq
+            = $iq({to: this.focusMucJid, type: 'set'})
+                .c('jibri', {
+                    'xmlns': 'http://jitsi.org/protocol/jibri',
+                    'action': state === Recording.status.ON
+                            ? Recording.action.START
+                            : Recording.action.STOP,
+                    'streamid': options.streamId,
+                })
+                .up();
 
         logger.log(`Set jibri recording: ${state}`, iq.nodeTree);
         logger.log(iq.nodeTree);
         iq,
         result => {
             logger.log('Result', result);
-            callback($(result).find('jibri').attr('state'),
-            $(result).find('jibri').attr('url'));
+
+            const jibri = $(result).find('jibri');
+
+            callback(jibri.attr('state'), jibri.attr('url'));
         },
         error => {
             logger.log('Failed to start recording, error: ', error);
                 ? Recording.action.START
                 : Recording.action.STOP,
             mucjid: this.roomjid});
+
         if (state === 'off') {
             iq.attrs({rid: this.jireconRid});
         }
 
         logger.log('Start recording');
         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 ${
 Recording.prototype.setRecordingColibri
 = function(state, callback, errCallback, options) {
     const elem = $iq({to: this.focusMucJid, type: 'set'});
+
     elem.c('conference', {
         xmlns: 'http://jitsi.org/protocol/colibri'
     });
     elem.c('recording', {state, token: options.token});
 
     const self = this;
+
     this.connection.sendIQ(elem,
         result => {
             logger.log('Set recording "', state, '". Result:', result);
 
             if (newState === 'pending') {
                 self.connection.addHandler(iq => {
+                    // eslint-disable-next-line newline-per-chained-call
                     const state = $(iq).find('recording').attr('state');
+
                     if (state) {
                         self.state = newState;
                         callback(state);
         break;
     default: {
         const errmsg = 'Unknown recording type!';
+
         GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
         logger.error(errmsg);
         break;
         statusChangeHandler(Recording.status.FAILED,
                             JitsiRecorderErrors.NO_TOKEN);
         logger.error('No token passed!');
+
         return;
     }
 
                     : Recording.status.OFF;
 
     const self = this;
+
     logger.log('Toggle recording (old state, new state): ', oldState, newState);
     this.setRecording(
         newState,

modules/xmpp/strophe.emuc.js

 
 import {getLogger} from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
+
 import ChatRoom from './ChatRoom';
 import {ConnectionPluginListenable} from './ConnectionPlugin';
 import XMPPEvents from '../../service/xmpp/XMPPEvents';
 
     createRoom(jid, password, options) {
         const roomJid = Strophe.getBareJidFromJid(jid);
+
         if (this.rooms[roomJid]) {
             const errmsg = 'You are already in the room!';
+
             logger.error(errmsg);
             throw new Error(errmsg);
         }
             password, this.xmpp, options);
         this.eventEmitter.emit(
             XMPPEvents.EMUC_ROOM_ADDED, this.rooms[roomJid]);
+
         return this.rooms[roomJid];
     }
 
         }
 
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
+
         if(!room) {
             return;
         }
     onPresenceUnavailable(pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
+
         if(!room) {
             return;
         }
 
         room.onPresenceUnavailable(pres, from);
+
         return true;
     }
 
     onPresenceError(pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
+
         if(!room) {
             return;
         }
 
         room.onPresenceError(pres, from);
+
         return true;
     }
 
         // FIXME: this is a hack. but jingle on muc makes nickchanges hard
         const from = msg.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
+
         if(!room) {
             return;
         }
 
         room.onMessage(msg, from);
+
         return true;
     }
 
     onMute(iq) {
         const from = iq.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
+
         if(!room) {
             return;
         }
 
         room.onMute(iq);
+
         return true;
     }
 }

modules/xmpp/strophe.jingle.js

 
 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
+
 import JingleSessionPC from './JingleSessionPC';
 import XMPPEvents from '../../service/xmpp/XMPPEvents';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Statistics from '../statistics/statistics';
 import ConnectionPlugin from './ConnectionPlugin';
 
+// XXX Strophe is build around the idea of chaining function calls so allow long
+// function call chains.
+/* eslint-disable newline-per-chained-call */
+
 class JingleConnectionPlugin extends ConnectionPlugin {
     constructor(xmpp, eventEmitter) {
         super();
             to: fromJid,
             id: iq.getAttribute('id')
         });
+
         logger.log(`on jingle ${action} from ${fromJid}`, iq);
         let sess = this.sessions[sid];
+
         if ('session-initiate' != action) {
             if (!sess) {
                 ack.attrs({ type: 'error' });
                     .c('unknown-session', {xmlns: 'urn:xmpp:jingle:errors:1'});
                 logger.warn('invalid session id', iq);
                 this.connection.send(ack);
+
                 return true;
             }
             // local jid is not checked
                     .c('item-not-found', {xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'}).up()
                     .c('unknown-session', {xmlns: 'urn:xmpp:jingle:errors:1'});
                 this.connection.send(ack);
+
                 return true;
             }
         } else if (sess !== undefined) {
                 .c('service-unavailable', {xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'}).up();
             logger.warn('duplicate session id', sid, iq);
             this.connection.send(ack);
+
             return true;
         }
         const now = window.performance.now();
         // see http://xmpp.org/extensions/xep-0166.html#concepts-session
+
         switch (action) {
         case 'session-initiate': {
             logger.log('(TIME) received session-initiate:\t', now);
             const startMuted = $(iq).find('jingle>startmuted');
+
             if (startMuted && startMuted.length > 0) {
                 const audioMuted = startMuted.attr('audio');
                 const videoMuted = startMuted.attr('video');
+
                 this.eventEmitter.emit(XMPPEvents.START_MUTED_FROM_FOCUS,
                             audioMuted === 'true', videoMuted === 'true');
             }
             logger.log('terminating...', sess.sid);
             let reasonCondition = null;
             let reasonText = null;
+
             if ($(iq).find('>jingle>reason').length) {
                 reasonCondition
-                        = $(iq).find('>jingle>reason>:first')[0].tagName;
+                    = $(iq).find('>jingle>reason>:first')[0].tagName;
                 reasonText = $(iq).find('>jingle>reason>text').text();
             }
             this.terminate(sess.sid, reasonCondition, reasonText);
 
             sess.replaceTransport($(iq).find('>jingle'), () => {
                 const successTime = window.performance.now();
+
                 logger.info(
                         '(TIME) Transport replace success!', successTime);
                 Statistics.analytics.sendEvent(
             break;
         }
         this.connection.send(ack);
+
         return true;
     }
 
                 .c('service', {host: `turn.${this.connection.domain}`}),
             res => {
                 const iceservers = [];
+
                 $(res).find('>services>service').each((idx, el) => {
                     el = $(el);
                     const dict = {};
                     const type = el.attr('type');
+
                     switch (type) {
                     case 'stun':
                         dict.url = `stun:${el.attr('host')}`;
                         dict.url = `${type}:`;
                         const username = el.attr('username');
                             // https://code.google.com/p/webrtc/issues/detail?id=1508
+
                         if (username) {
                             if (navigator.userAgent.match(
                                     /Chrom(e|ium)\/([0-9]+)\./)
                         }
                         dict.url += el.attr('host');
                         const port = el.attr('port');
+
                         if (port && port != '3478') {
                             dict.url += `:${el.attr('port')}`;
                         }
                         const transport = el.attr('transport');
+
                         if (transport && transport != 'udp') {
                             dict.url += `?transport=${transport}`;
                         }
      */
     getLog() {
         const data = {};
+
         Object.keys(this.sessions).forEach(sid => {
             const session = this.sessions[sid];
             const pc = session.peerconnection;
+
             if (pc && pc.updateLog) {
                 // FIXME: should probably be a .dump call
                 data[`jingle_${sid}`] = {
                 };
             }
         });
+
         return data;
     }
 }
 
+/* eslint-enable newline-per-chained-call */
 
 module.exports = function(XMPP, eventEmitter) {
-    Strophe.addConnectionPlugin('jingle',
+    Strophe.addConnectionPlugin(
+        'jingle',
         new JingleConnectionPlugin(XMPP, eventEmitter));
 };

modules/xmpp/strophe.ping.js

 
 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
+
 import ConnectionPlugin from './ConnectionPlugin';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
      */
     ping(jid, success, error, timeout) {
         const iq = $iq({type: 'get', to: jid});
+
         iq.c('ping', {xmlns: Strophe.NS.PING});
         this.connection.sendIQ(iq, success, error, timeout);
     }
         this.xmpp.caps.getFeatures(jid).then(features =>
             callback(features.has('urn:xmpp:ping')), error => {
             const errmsg = 'Ping feature discovery error';
+
             GlobalOnErrorHandler.callErrorHandler(
                 new Error(`${errmsg}: ${error}`));
             logger.error(errmsg, error);
     startInterval(remoteJid, interval = PING_INTERVAL) {
         if (this.intervalId) {
             const errmsg = 'Ping task scheduled already';
+
             GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
             logger.error(errmsg);
+
             return;
         }
         this.intervalId = window.setInterval(() => {
             }, error => {
                 this.failedPings += 1;
                 const errmsg = `Ping ${error ? 'error' : 'timeout'}`;
+
                 if (this.failedPings >= PING_THRESHOLD) {
                     GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
                     logger.error(errmsg, error);

modules/xmpp/strophe.rayo.js

 
 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
+
 import ConnectionPlugin from './ConnectionPlugin';
 
 const RAYO_XMLNS = 'urn:xmpp:rayo:1';
         return new Promise((resolve, reject) => {
             if(!focusMucJid) {
                 reject(new Error('Internal error!'));
+
                 return;
             }
             const req = $iq({
                 type: 'set',
                 to: focusMucJid
             });
+
             req.c('dial', {
                 xmlns: RAYO_XMLNS,
                 to,
             this.connection.sendIQ(req, result => {
                 logger.info('Dial result ', result);
 
+                // eslint-disable-next-line newline-per-chained-call
                 const resource = $(result).find('ref').attr('uri');
-                this.call_resource
-                    = resource.substr('xmpp:'.length);
+
+                this.call_resource = resource.substr('xmpp:'.length);
                 logger.info(`Received call resource: ${this.call_resource}`);
                 resolve();
             }, error => {
             if (!this.call_resource) {
                 reject(new Error('No call in progress'));
                 logger.warn('No call in progress');
+
                 return;
             }
 
                 type: 'set',
                 to: this.call_resource
             });
+
             req.c('hangup', {
                 xmlns: RAYO_XMLNS
             });

modules/xmpp/strophe.util.js

  */
 import {getLogger} from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
+
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
 /**
         case Strophe.LogLevel.WARN:
             logger.warn(`Strophe: ${msg}`);
             const errStatusCapture = lastErrorStatusRegExpr.exec(msg);
+
             if (errStatusCapture && errStatusCapture.length === 2) {
                 lastErrorStatus = parseInt(errStatusCapture[1]);
                 logger.debug(

modules/xmpp/xmpp.js

 
 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
+
 import RandomUtil from '../util/RandomUtil';
 import * as JitsiConnectionErrors from '../../JitsiConnectionErrors';
 import * as JitsiConnectionEvents from '../../JitsiConnectionEvents';
     connectionHandler(password, status, msg) {
         const now = window.performance.now();
         const statusStr = Strophe.getStatusString(status).toLowerCase();
+
         this.connectionTimes[statusStr] = now;
         logger.log(
             `(TIME) Strophe ${statusStr}${msg ? `[${msg}]` : ''}:\t`,
 
             // Schedule ping ?
             const pingJid = this.connection.domain;
+
             this.connection.ping.hasPingSupport(
                 pingJid,
                 hasPing => {
             this.connection.ping.stopInterval();
             const wasIntentionalDisconnect = this.disconnectInProgress;
             const errMsg = msg ? msg : this.lastErrorMsg;
+
             this.disconnectInProgress = false;
             if (this.anonymousConnectionFailed) {
                 // prompt user for username and password
                 // XXX if the last request error is within 5xx range it means it
                 // was a server failure
                 const lastErrorStatus = Strophe.getLastErrorStatus();
+
                 if (lastErrorStatus >= 500 && lastErrorStatus < 600) {
                     this.eventEmitter.emit(
                         JitsiConnectionEvents.CONNECTION_FAILED,
      */
     attach(options) {
         const now = this.connectionTimes.attaching = window.performance.now();
+
         logger.log(`(TIME) Strophe Attaching\t:${now}`);
         this.connection.attach(options.jid, options.sid,
             parseInt(options.rid,10) + 1,
                     || this.options.hosts.domain;
             // Force authenticated domain if room is appended with '?login=true'
             // or if we're joining with the token
+
             if (this.options.hosts.anonymousdomain
                     && (window.location.search.indexOf('login=true') !== -1
                         || this.options.token)) {
             }
             jid = configDomain || window.location.hostname;
         }
+
         return this._connect(jid, password);
     }
 
      */
     getJingleLog() {
         const jingle = this.connection.jingle;
+
+
         return jingle ? jingle.getLog() : {};
     }
 
                 || !this.connection
                 || !this.connection.connected) {
             this.eventEmitter.emit(JitsiConnectionEvents.WRONG_STATE);
+
             return;
         }
 

service/RTC/Resolutions.js

         order: 1
     }
 };
+
 module.exports = Resolutions;

service/RTC/VideoType.js

      */
     DESKTOP: 'desktop'
 };
+
 module.exports = VideoType;

service/authentication/AuthenticationEvents.js

      */
     IDENTITY_UPDATED: 'authentication.identity_updated'
 };
+
 module.exports = AuthenticationEvents;

service/statistics/constants.js

 const Constants = {
     LOCAL_JID: 'local'
 };
+
 module.exports = Constants;

service/xmpp/XMPPEvents.js

     // changed.
     ICE_CONNECTION_STATE_CHANGED: 'xmpp.ice_connection_state_changed'
 };
+
 module.exports = XMPPEvents;