fix(eslint): Add no-multi-spaces rule

.eslintrc.js

         'complexity': 0,
         'consistent-return': 0,
         'curly': 2,
+        'no-multi-spaces': 2,
 
         // Stylistic issues group
         'brace-style': 2,

JitsiConference.js

  * @param connection {JitsiConnection} overrides this.connection
  */
 JitsiConference.prototype._init = function (options) {
-    if (!options)        {
+    if (!options) {
         options = {};
     }
 
  * @param password {string} the password
  */
 JitsiConference.prototype.join = function (password) {
-    if (this.room)        {
+    if (this.room) {
         this.room.join(password);
     }
 };
     this.getLocalTracks().forEach(track => this.onLocalTrackRemoved(track));
 
     this.rtc.closeAllDataChannels();
-    if (this.statistics)        {
+    if (this.statistics) {
         this.statistics.dispose();
     }
 
  * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
  */
 JitsiConference.prototype.on = function (eventId, handler) {
-    if (this.eventEmitter)        {
+    if (this.eventEmitter) {
         this.eventEmitter.on(eventId, handler);
     }
 };
  * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
  */
 JitsiConference.prototype.off = function (eventId, handler) {
-    if (this.eventEmitter)        {
+    if (this.eventEmitter) {
         this.eventEmitter.removeListener(eventId, handler);
     }
 };
  * @param handler {Function} handler for the command
  */
 JitsiConference.prototype.addCommandListener = function (command, handler) {
-    if (this.room)        {
+    if (this.room) {
         this.room.addPresenceListener(command, handler);
     }
 };
   * @param command {String} the name of the command
   */
 JitsiConference.prototype.removeCommandListener = function (command) {
-    if (this.room)        {
+    if (this.room) {
         this.room.removePresenceListener(command);
     }
 };
  * @param message the text message.
  */
 JitsiConference.prototype.sendTextMessage = function (message) {
-    if (this.room)        {
+    if (this.room) {
         this.room.sendMessage(message);
     }
 };
  * @param name {String} the name of the command.
  **/
 JitsiConference.prototype.removeCommand = function (name) {
-    if (this.room)        {
+    if (this.room) {
         this.room.removeFromPresence(name);
     }
 };
     // send event for stopping screen sharing
     // FIXME: we assume we have only one screen sharing track
     // if we change this we need to fix this check
-    if (track.isVideoTrack() && track.videoType === VideoType.DESKTOP)        {
+    if (track.isVideoTrack() && track.videoType === VideoType.DESKTOP) {
         this.statistics.sendScreenSharingEvent(false);
     }
 
     // send event for starting screen sharing
     // FIXME: we assume we have only one screen sharing track
     // if we change this we need to fix this check
-    if (newTrack.isVideoTrack() && newTrack.videoType === VideoType.DESKTOP)        {
+    if (newTrack.isVideoTrack() && newTrack.videoType === VideoType.DESKTOP) {
         this.statistics.sendScreenSharingEvent(true);
     }
 
     }.bind(this));
 
     // there can be no participant in case the member that left is focus
-    if (participant)        {
+    if (participant) {
         this.eventEmitter.emit(
             JitsiConferenceEvents.USER_LEFT, id, participant);
     }
         return;
     }
 
-    if (participant._displayName === displayName)        {
+    if (participant._displayName === displayName) {
         return;
     }
 
  * Returns true if recording is supported and false if not.
  */
 JitsiConference.prototype.isRecordingSupported = function () {
-    if (this.room)        {
+    if (this.room) {
         return this.room.isRecordingSupported();
     }
     return false;
  * Starts/stops the recording
  */
 JitsiConference.prototype.toggleRecording = function (options) {
-    if (this.room)        {
+    if (this.room) {
         return this.room.toggleRecording(options, function (status, error) {
             this.eventEmitter.emit(
                 JitsiConferenceEvents.RECORDER_STATE_CHANGED, status, error);
  * Returns true if the SIP calls are supported and false otherwise
  */
 JitsiConference.prototype.isSIPCallingSupported = function () {
-    if (this.room)        {
+    if (this.room) {
         return this.room.isSIPCallingSupported();
     }
     return false;
  * @param number the number
  */
 JitsiConference.prototype.dial = function (number) {
-    if (this.room)        {
+    if (this.room) {
         return this.room.dial(number);
     }
     return new Promise(function(resolve, reject){
  * Hangup an existing call
  */
 JitsiConference.prototype.hangup = function () {
-    if (this.room)        {
+    if (this.room) {
         return this.room.hangup();
     }
     return new Promise(function(resolve, reject){
  * Returns the phone number for joining the conference.
  */
 JitsiConference.prototype.getPhoneNumber = function () {
-    if (this.room)        {
+    if (this.room) {
         return this.room.getPhoneNumber();
     }
     return null;
  * Returns the pin for joining the conference with phone.
  */
 JitsiConference.prototype.getPhonePin = function () {
-    if (this.room)        {
+    if (this.room) {
         return this.room.getPhonePin();
     }
     return null;

JitsiConferenceEventManager.js

     //Listeners related to the conference only
     conference.on(JitsiConferenceEvents.TRACK_MUTE_CHANGED,
         function (track) {
-            if(!track.isLocal() || !conference.statistics)                {
+            if(!track.isLocal() || !conference.statistics) {
                 return;
             }
             conference.statistics.sendMuteEvent(track.isMuted(),
  */
 JitsiConferenceEventManager.prototype.setupStatisticsListeners = function () {
     var conference = this.conference;
-    if(!conference.statistics)        {
+    if(!conference.statistics) {
         return;
     }
 
     conference.statistics.addAudioLevelListener(function (ssrc, level) {
         var resource = conference.rtc.getResourceBySSRC(ssrc);
-        if (!resource)            {
+        if (!resource) {
             return;
         }
 
     conference.statistics.addByteSentStatsListener(function (stats) {
         conference.getLocalTracks(MediaType.AUDIO).forEach(function (track) {
             const ssrc = track.getSSRC();
-            if (!ssrc || !stats.hasOwnProperty(ssrc))                {
+            if (!ssrc || !stats.hasOwnProperty(ssrc)) {
                 return;
             }
 

JitsiConnection.js

             // we can see disconnects from normal tab closing of the browser
             // and then there are no msgs, but we want to log only disconnects
             // when there is real error
-            if(msg)                {
+            if(msg) {
                 Statistics.analytics.sendEvent(
                     'connection.disconnected.' + msg);
             }
  * (for example authentications parameters).
  */
 JitsiConnection.prototype.connect = function (options) {
-    if(!options)        {
+    if(!options) {
         options = {};
     }
 

JitsiMediaDevices.js

     setAudioOutputDevice: function (deviceId) {
 
         var availableDevices = RTC.getCurrentlyAvailableMediaDevices();
-        if (availableDevices && availableDevices.length > 0)        {
+        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
             // too early. This will happen only on user selection of new device

JitsiMeetJS.js

 var USER_MEDIA_PERMISSION_PROMPT_TIMEOUT = 500;
 
 function getLowerResolution(resolution) {
-    if(!Resolutions[resolution])        {
+    if(!Resolutions[resolution]) {
         return null;
     }
     var order = Resolutions[resolution].order;
             }, USER_MEDIA_PERMISSION_PROMPT_TIMEOUT);
         }
 
-        if(!window.connectionTimes)            {
+        if(!window.connectionTimes) {
             window.connectionTimes = {};
         }
         window.connectionTimes["obtainPermissions.start"] =
                 Statistics.analytics.sendEvent(addDeviceTypeToAnalyticsEvent(
                     "getUserMedia.success", options), {value: options});
 
-                if(!RTC.options.disableAudioLevels)                    {
+                if(!RTC.options.disableAudioLevels) {
                     for(let i = 0; i < tracks.length; i++) {
                         const track = tracks[i];
                         var mStream = track.getOriginalStream();

doc/example/example.js

  */
 function onLocalTracks(tracks){
     localTracks = tracks;
-    for(var i = 0; i < localTracks.length; i++)    {
+    for(var i = 0; i < localTracks.length; i++) {
         localTracks[i].addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
             function (audioLevel) {
                 console.log("Audio Level local: " + audioLevel);
             $("body").append("<audio autoplay='1' muted='true' id='localAudio" + i + "' />");
             localTracks[i].attach($("#localAudio" + i)[0]);
         }
-        if(isJoined)            {
+        if(isJoined) {
             room.addTrack(localTracks[i]);
         }
     }
  * @param track JitsiTrack object
  */
 function onRemoteTrack(track) {
-    if(track.isLocal())        {
+    if(track.isLocal()) {
         return;
     }
     var participant = track.getParticipantId();
-    if(!remoteTracks[participant])        {
+    if(!remoteTracks[participant]) {
         remoteTracks[participant] = [];
     }
     var idx = remoteTracks[participant].push(track);
 function onConferenceJoined () {
     console.log("conference joined!");
     isJoined = true;
-    for(var i = 0; i < localTracks.length; i++)        {
+    for(var i = 0; i < localTracks.length; i++) {
         room.addTrack(localTracks[i]);
     }
 }
 
 function onUserLeft(id) {
     console.log("user left");
-    if(!remoteTracks[id])        {
+    if(!remoteTracks[id]) {
         return;
     }
     var tracks = remoteTracks[id];
-    for(var i = 0; i< tracks.length; i++)        {
+    for(var i = 0; i< tracks.length; i++) {
         tracks[i].detach($("#" + id + tracks[i].getType()));
     }
 }
 }
 
 function unload() {
-    for(var i = 0; i < localTracks.length; i++)        {
+    for(var i = 0; i < localTracks.length; i++) {
         localTracks[i].stop();
     }
     room.leave();

modules/RTC/DataChannels.js

 
         try {
             obj = JSON.parse(data);
-        }        catch (e) {
+        } catch (e) {
             GlobalOnErrorHandler.callErrorHandler(e);
             logger.error(
                 "Failed to parse data channel message as JSON: ",
                     dominantSpeakerEndpoint);
                 self.eventEmitter.emit(RTCEvents.DOMINANT_SPEAKER_CHANGED,
                   dominantSpeakerEndpoint);
-            }            else if ("InLastNChangeEvent" === colibriClass) {
+            } else if ("InLastNChangeEvent" === colibriClass) {
                 var oldValue = obj.oldValue;
                 var newValue = obj.newValue;
 
                 }
 
                 self.eventEmitter.emit(RTCEvents.LASTN_CHANGED, oldValue, newValue);
-            }            else if ("LastNEndpointsChangeEvent" === colibriClass) {
+            } else if ("LastNEndpointsChangeEvent" === colibriClass) {
                 // The new/latest list of last-n endpoint IDs.
                 var lastNEndpoints = obj.lastNEndpoints;
                 // The list of endpoint IDs which are entering the list of
                 self.eventEmitter.emit(
                     RTCEvents.ENDPOINT_MESSAGE_RECEIVED, obj.from,
                     obj.msgPayload);
-            }            else if ("EndpointConnectivityStatusChangeEvent" === colibriClass) {
+            } else if ("EndpointConnectivityStatusChangeEvent" === colibriClass) {
                 var endpoint = obj.endpoint;
                 var isActive = obj.active === "true";
                 logger.info("Endpoint connection status changed: " + endpoint
                            + " active ? " + isActive);
                 self.eventEmitter.emit(RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
                     endpoint, isActive);
-            }            else {
+            } else {
                 logger.debug("Data channel JSON-formatted message: ", obj);
                 // The received message appears to be appropriately formatted
                 // (i.e. is a JSON object which assigns a value to the mandatory
     dataChannel.onclose = function () {
         logger.info("The Data Channel closed", dataChannel);
         var idx = self._dataChannels.indexOf(dataChannel);
-        if (idx > -1)            {
+        if (idx > -1) {
             self._dataChannels = self._dataChannels.splice(idx, 1);
         }
     };
     var dataChannels = this._dataChannels;
 
     if (dataChannels && dataChannels.length !== 0) {
-        if (thisArg)            {
+        if (thisArg) {
             return dataChannels.some(callback, thisArg);
-        }        else            {
+        } else {
             return dataChannels.some(callback);
         }
     } else {

modules/RTC/JitsiLocalTrack.js

     JitsiTrack.call(this,
         null /* RTC */, stream, track,
         function () {
-            if(!this.dontFireRemoveEvent)                {
+            if(!this.dontFireRemoveEvent) {
                 this.eventEmitter.emit(
                     JitsiTrackEvents.LOCAL_TRACK_STOPPED);
             }
 
     // FIXME: currently firefox is ignoring our constraints about resolutions
     // so we do not store it, to avoid wrong reporting of local track resolution
-    if (RTCBrowserType.isFirefox())        {
+    if (RTCBrowserType.isFirefox()) {
         this.resolution = null;
     }
 
  * @returns {boolean}
  */
 JitsiLocalTrack.prototype.isEnded = function () {
-    return  this.getTrack().readyState === 'ended' || this._trackEnded;
+    return this.getTrack().readyState === 'ended' || this._trackEnded;
 };
 
 /**
  */
 JitsiLocalTrack.prototype._onNoDataFromSourceError = function () {
     this._clearNoDataFromSourceMuteResources();
-    if(this._checkForCameraIssues())        {
+    if(this._checkForCameraIssues()) {
         this._fireNoDataFromSourceEvent();
     }
 };
     if (this.isAudioTrack() ||
         this.videoType === VideoType.DESKTOP ||
         RTCBrowserType.isFirefox()) {
-        if(this.track)            {
+        if(this.track) {
             this.track.enabled = !mute;
         }
     } else {
                 devices: [ MediaType.VIDEO ],
                 facingMode: this.getCameraFacingMode()
             };
-            if (this.resolution)                {
+            if (this.resolution) {
                 streamOptions.resolution = this.resolution;
             }
 
  */
 JitsiLocalTrack.prototype.isMuted = function () {
     // this.stream will be null when we mute local video on Chrome
-    if (!this.stream)        {
+    if (!this.stream) {
         return true;
     }
     if (this.isVideoTrack() && !this.isActive()) {
     // on "attach" call, but for local track we not always have the conference
     // before attaching. However this may result in duplicated events if they
     // have been triggered on "attach" already.
-    for(var i = 0; i < this.containers.length; i++)    {
+    for(var i = 0; i < this.containers.length; i++) {
         this._maybeFireTrackAttached(this.containers[i]);
     }
 };
  * @returns {string} or {null}
  */
 JitsiLocalTrack.prototype.getSSRC = function () {
-    if(this.ssrc && this.ssrc.groups && this.ssrc.groups.length)        {
+    if(this.ssrc && this.ssrc.groups && this.ssrc.groups.length) {
         return this.ssrc.groups[0].ssrcs[0];
-    }    else if(this.ssrc && this.ssrc.ssrcs && this.ssrc.ssrcs.length)        {
+    } else if(this.ssrc && this.ssrc.ssrcs && this.ssrc.ssrcs.length) {
         return this.ssrc.ssrcs[0];
-    }    else        {
+    } else {
         return null;
     }
 };
  */
 JitsiLocalTrack.prototype._checkForCameraIssues = function () {
     if(!this.isVideoTrack() || this.stopStreamInProgress ||
-        this.videoType === VideoType.DESKTOP)        {
+        this.videoType === VideoType.DESKTOP) {
         return false;
     }
 
  * @returns {boolean} true if the stream is receiving data and false otherwise.
  */
 JitsiLocalTrack.prototype._isReceivingData = function () {
-    if(!this.stream)        {
+    if(!this.stream) {
         return false;
     }
     // In older version of the spec there is no muted property and

modules/RTC/JitsiRemoteTrack.js

     // increase ttfm values
     this.hasBeenMuted = muted;
     // Bind 'onmute' and 'onunmute' event handlers
-    if (this.rtc && this.track)        {
+    if (this.rtc && this.track) {
         this._bindMuteHandlers();
     }
 }
  * @param value the muted status.
  */
 JitsiRemoteTrack.prototype.setMute = function (value) {
-    if(this.muted === value)        {
+    if(this.muted === value) {
         return;
     }
 
-    if(value)        {
+    if(value) {
         this.hasBeenMuted = true;
     }
 
     // we can have a fake video stream
-    if(this.stream)        {
+    if(this.stream) {
         this.stream.muted = value;
     }
 
  * @param type the new video type("camera", "desktop")
  */
 JitsiRemoteTrack.prototype._setVideoType = function (type) {
-    if(this.videoType === type)        {
+    if(this.videoType === type) {
         return;
     }
     this.videoType = type;
     this.conference.getConnectionTimes()[type + ".ttfm"] = ttfm;
     console.log("(TIME) TTFM " + type + ":\t", ttfm);
     var eventName = type +'.ttfm';
-    if(this.hasBeenMuted)        {
+    if(this.hasBeenMuted) {
         eventName += '.muted';
     }
     Statistics.analytics.sendEvent(eventName, {value: ttfm});
  */
 JitsiRemoteTrack.prototype._attachTTFMTracker = function (container) {
     if((ttfmTrackerAudioAttached && this.isAudioTrack())
-        || (ttfmTrackerVideoAttached && this.isVideoTrack()))        {
+        || (ttfmTrackerVideoAttached && this.isVideoTrack())) {
         return;
     }
 
-    if (this.isAudioTrack())        {
+    if (this.isAudioTrack()) {
         ttfmTrackerAudioAttached = true;
     }
-    if (this.isVideoTrack())        {
+    if (this.isVideoTrack()) {
         ttfmTrackerVideoAttached = true;
     }
 
 
         // FIXME: this is not working for IE11
         AdapterJS.addEvent(container, 'play', this._playCallback.bind(this));
-    }    else {
+    } else {
         container.addEventListener("canplay", this._playCallback.bind(this));
     }
 };

modules/RTC/JitsiTrack.js

 function implementOnEndedHandling(jitsiTrack) {
     var stream = jitsiTrack.getOriginalStream();
 
-    if(!stream)        {
+    if(!stream) {
         return;
     }
 
  */
 function addMediaStreamInactiveHandler(mediaStream, handler) {
     // Temasys will use onended
-    if(typeof mediaStream.active !== "undefined")        {
+    if(typeof mediaStream.active !== "undefined") {
         mediaStream.oninactive = handler;
-    }    else        {
+    } else {
         mediaStream.onended = handler;
     }
 }
  */
 JitsiTrack.prototype._setHandler = function (type, handler) {
     this.handlers[type] = handler;
-    if(!this.stream)        {
+    if(!this.stream) {
         return;
     }
 
  * @returns {string|null} id of the track or null if this is fake track.
  */
 JitsiTrack.prototype.getId = function () {
-    if(this.stream)        {
+    if(this.stream) {
         return RTCUtils.getStreamID(this.stream);
-    }    else        {
+    } else {
         return null;
     }
 };
  * @returns {boolean} whether MediaStream is active.
  */
 JitsiTrack.prototype.isActive = function () {
-    if(typeof this.stream.active !== "undefined")        {
+    if(typeof this.stream.active !== "undefined") {
         return this.stream.active;
-    }    else        {
+    } else {
         return true;
     }
 };
  * @param handler handler for the event.
  */
 JitsiTrack.prototype.on = function (eventId, handler) {
-    if(this.eventEmitter)        {
+    if(this.eventEmitter) {
         this.eventEmitter.on(eventId, handler);
     }
 };
  * @param [handler] optional, the specific handler to unbind
  */
 JitsiTrack.prototype.off = function (eventId, handler) {
-    if(this.eventEmitter)        {
+    if(this.eventEmitter) {
         this.eventEmitter.removeListener(eventId, handler);
     }
 };

modules/RTC/RTC.js

     selectEndpoint (id) {
         // cache the value if channel is missing, till we open it
         this.selectedEndpoint = id;
-        if(this.dataChannels && this.dataChannelsOpen)            {
+        if(this.dataChannels && this.dataChannelsOpen) {
             this.dataChannels.sendSelectedEndpointMessage(id);
         }
     }
     }
 
     addLocalTrack (track) {
-        if (!track)            {
+        if (!track) {
             throw new Error('track must not be null nor undefined');
         }
 
      * @returns {JitsiRemoteTrack|null}
      */
     getRemoteTrackByType (type, resource) {
-        if (this.remoteTracks[resource])            {
+        if (this.remoteTracks[resource]) {
             return this.remoteTracks[resource][type];
-        }        else            {
+        } else {
             return null;
         }
     }
     dispose () { }
 
     setAudioLevel (resource, audioLevel) {
-        if(!resource)            {
+        if(!resource) {
             return;
         }
         var audioTrack = this.getRemoteAudioTrack(resource);

modules/RTC/RTCBrowserType.js

     // Try all browser detectors
     for (var i = 0; i < detectors.length; i++) {
         version = detectors[i]();
-        if (version)            {
+        if (version) {
             return version;
         }
     }

modules/RTC/RTCUtils.js

     if (Resolutions[resolution]) {
         constraints.video.mandatory.minWidth = Resolutions[resolution].width;
         constraints.video.mandatory.minHeight = Resolutions[resolution].height;
-    }    else if (isAndroid) {
+    } else if (isAndroid) {
         // FIXME can't remember if the purpose of this was to always request
         //       low resolution on Android ? if yes it should be moved up front
         constraints.video.mandatory.minWidth = 320;
         constraints.video.mandatory.maxFrameRate = 15;
     }
 
-    if (constraints.video.mandatory.minWidth)        {
+    if (constraints.video.mandatory.minWidth) {
         constraints.video.mandatory.maxWidth =
             constraints.video.mandatory.minWidth;
     }
-    if (constraints.video.mandatory.minHeight)        {
+    if (constraints.video.mandatory.minHeight) {
         constraints.video.mandatory.maxHeight =
             constraints.video.mandatory.minHeight;
     }
     // we turn audio for both audio and video tracks, the fake audio & video seems to work
     // only when enabled in one getUserMedia call, we cannot get fake audio separate by fake video
     // this later can be a problem with some of the tests
-    if(RTCBrowserType.isFirefox() && options.firefox_fake_device)    {
+    if(RTCBrowserType.isFirefox() && options.firefox_fake_device) {
         // seems to be fixed now, removing this experimental fix, as having
         // multiple audio tracks brake the tests
         //constraints.audio = true;
                     // https://github.com/webrtc/samples/issues/302
                     if (element) {
                         defaultSetVideoSrc(element, stream);
-                        if (stream)                            {
+                        if (stream) {
                             element.play();
                         }
                     }
                             var videoTracksReceived = !!stream.getVideoTracks().length;
 
                             if((audioDeviceRequested && !audioTracksReceived) ||
-                                (videoDeviceRequested && !videoTracksReceived))                            {
+                                (videoDeviceRequested && !videoTracksReceived)) {
                                 self.stopMediaStream(stream);
 
                                 // We are getting here in case if we requested
     }
 
     _isDeviceListAvailable () {
-        if (!rtcReady)            {
+        if (!rtcReady) {
             throw new Error("WebRTC not ready yet");
         }
         var isEnumerateDevicesAvailable

modules/RTC/ScreenObtainer.js

         this.options = options = options || {};
         gumFunction = gum;
 
-        if (RTCBrowserType.isFirefox())            {
+        if (RTCBrowserType.isFirefox()) {
             initFirefoxExtensionDetection(options);
         }
 
         if (firefoxExtInstalled === null) {
             window.setTimeout(
                 () => {
-                    if (firefoxExtInstalled === null)                        {
+                    if (firefoxExtInstalled === null) {
                         firefoxExtInstalled = false;
                     }
                     this.obtainScreenOnFirefox(callback, errorCallback);
             var n1 = 0,
                 n2 = 0;
 
-            if (i < s1.length)                {
+            if (i < s1.length) {
                 n1 = parseInt(s1[i]);
             }
-            if (i < s2.length)                {
+            if (i < s2.length) {
                 n2 = parseInt(s2[i]);
             }
 
         // will happen if both versions have identical numbers in
         // their components (even if one of them is longer, has more components)
         return false;
-    }    catch (e) {
+    } catch (e) {
         GlobalOnErrorHandler.callErrorHandler(e);
         logger.error("Failed to parse extension version", e);
         return true;
         // As noted in Chrome Desktop Capture API:
         // If user didn't select any source (i.e. canceled the prompt)
         // then the callback is called with an empty streamId.
-        if(response.streamId === "")        {
+        if(response.streamId === "") {
             onFailure(new JitsiTrackError(
                 JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED));
             return;
     if (options.desktopSharingFirefoxDisabled) {
         return;
     }
-    if (firefoxExtInstalled === false || firefoxExtInstalled === true)        {
+    if (firefoxExtInstalled === false || firefoxExtInstalled === true) {
         return;
     }
     if (!options.desktopSharingFirefoxExtId) {

modules/RTC/TraceablePeerConnection.js

 
 TraceablePeerConnection.prototype.addStream = function (stream, ssrcInfo) {
     this.trace('addStream', stream ? stream.id : "null");
-    if (stream)        {
+    if (stream) {
         this.peerconnection.addStream(stream);
     }
     if (ssrcInfo && ssrcInfo.type === "addMuted") {
             || RTCBrowserType.isTemasysPluginUsed()
             || RTCBrowserType.isReactNative()) {
         // ignore for now...
-        if(!errback)            {
+        if(!errback) {
             errback = function () {};
         }
         this.peerconnection.getStats(null, callback, errback);

modules/TalkMutedDetection.js

     _audioLevel(ssrc, audioLevel, isLocal) {
         // We are interested in the local audio stream only and if event is not
         // sent yet.
-        if (!isLocal || !this.audioTrack || this._eventFired)            {
+        if (!isLocal || !this.audioTrack || this._eventFired) {
             return;
         }
 
      * @private
      */
     _trackAdded(track) {
-        if (this._isLocalAudioTrack(track))            {
+        if (this._isLocalAudioTrack(track)) {
             this.audioTrack = track;
         }
     }
      * @private
      */
     _trackMuteChanged(track) {
-        if (this._isLocalAudioTrack(track) && track.isMuted())            {
+        if (this._isLocalAudioTrack(track) && track.isMuted()) {
             this._eventFired = false;
         }
     }

modules/connectivity/ConnectionQuality.js

  */
 const kSimulcastFormats = [
     { width: 1920, height: 1080, layers:3, max: 5000, target: 4000, min: 800 },
-    { width: 1280, height: 720,  layers:3, max: 2500, target: 2500, min: 600 },
-    { width: 960,  height: 540,  layers:3, max: 900,  target: 900, min: 450 },
-    { width: 640,  height: 360,  layers:2, max: 700,  target: 500, min: 150 },
-    { width: 480,  height: 270,  layers:2, max: 450,  target: 350, min: 150 },
-    { width: 320,  height: 180,  layers:1, max: 200,  target: 150, min: 30 }
+    { width: 1280, height: 720, layers:3, max: 2500, target: 2500, min: 600 },
+    { width: 960, height: 540, layers:3, max: 900, target: 900, min: 450 },
+    { width: 640, height: 360, layers:2, max: 700, target: 500, min: 150 },
+    { width: 480, height: 270, layers:2, max: 450, target: 350, min: 150 },
+    { width: 320, height: 180, layers:1, max: 200, target: 150, min: 30 }
 ];
 
 /**
         if (pixels <= 320 * 240) {
             target = 600;
         } else if (pixels <= 640 * 480) {
-            target =  1700;
+            target = 1700;
         } else if (pixels <= 960 * 540) {
             target = 2000;
         } else {
         conference.on(
             ConferenceEvents.TRACK_ADDED,
             (track) => {
-                if (track.isVideoTrack() && !track.isMuted())                {
+                if (track.isVideoTrack() && !track.isMuted()) {
                     this._maybeUpdateUnmuteTime();
                 }
             });
         }
 
         // Make sure that the quality doesn't climb quickly
-        if (this._lastConnectionQualityUpdate > 0)        {
+        if (this._lastConnectionQualityUpdate > 0) {
             const maxIncreasePerSecond = 2;
             const prevConnectionQuality = this._localStats.connectionQuality;
             const diffSeconds

modules/statistics/CallStats.js

  */
 CallStats._checkInitialize = function () {
     if (CallStats.initialized || !CallStats.initializeFailed
-        || !callStats || CallStats.initializeInProgress)        {
+        || !callStats || CallStats.initializeInProgress) {
         return;
     }
 
 };
 
 CallStats.prototype.pcCallback = _try_catch(function (err, msg) {
-    if (callStats && err !== 'success')        {
+    if (callStats && err !== 'success') {
         logger.error("Monitoring status: "+ err + " msg: " + msg);
     }
 });
                 ssrc,
                 usageLabel,
                 containerId);
-        }        else {
+        } else {
             CallStats.reportsQueue.push({
                 type: reportType.MST_WITH_USERID,
                 data: {

modules/statistics/LocalStatsCollector.js

     var length = samples.length;
 
     for (var i = 0; i < length; i++) {
-        if (maxVolume < samples[i])            {
+        if (maxVolume < samples[i]) {
             maxVolume = samples[i];
         }
     }
     var diff = lastLevel - newLevel;
     if(diff > 0.2) {
         value = lastLevel - 0.2;
-    }    else if(diff < -0.4) {
+    } else if(diff < -0.4) {
         value = lastLevel + 0.4;
-    }    else {
+    } else {
         value = newLevel;
     }
 
  */
 LocalStatsCollector.prototype.start = function () {
     if (!context ||
-        RTCBrowserType.isTemasysPluginUsed())        {
+        RTCBrowserType.isTemasysPluginUsed()) {
         return;
     }
     context.resume();

modules/statistics/RTPStatsCollector.js

  * @returns {number} packet loss percent
  */
 function calculatePacketLoss(lostPackets, totalPackets) {
-    if(!totalPackets || totalPackets <= 0 || !lostPackets || lostPackets <= 0)        {
+    if(!totalPackets || totalPackets <= 0 || !lostPackets || lostPackets <= 0) {
         return 0;
     }
     return Math.round((lostPackets/totalPackets)*100);
      */
     this._browserType = RTCBrowserType.getBrowserType();
     var keys = KEYS_BY_BROWSER_TYPE[this._browserType];
-    if (!keys)        {
+    if (!keys) {
         throw "The browser type '" + this._browserType + "' isn't supported!";
     }
     /**
                         if (!report || !report.result ||
                             typeof report.result != 'function') {
                             results = report;
-                        }                        else {
+                        } else {
                             results = report.result();
                         }
                         self.currentAudioLevelsReport = results;
                             typeof report.result != 'function') {
                             //firefox
                             results = report;
-                        }                        else {
+                        } else {
                             //chrome
                             results = report.result();
                         }
                         self.currentStatsReport = results;
                         try {
                             self.processStatsReport();
-                        }                        catch (e) {
+                        } catch (e) {
                             GlobalOnErrorHandler.callErrorHandler(e);
                             logger.error("Unsupported key:" + e, e);
                         }
     // RTCPeerConnection#getStats.
     var keyFromName = function (name) {
         var key = keys[name];
-        if (key)            {
+        if (key) {
             return key;
-        }        else            {
+        } else {
             throw "The property '" + name + "' isn't supported!";
         }
     };
                     "upload": Math.round(sendBandwidth / 1000)
                 };
             }
-        }        catch(e){/*not supported*/}
+        } catch(e){/*not supported*/}
 
-        if(now.type == 'googCandidatePair')        {
+        if(now.type == 'googCandidatePair') {
             var ip, type, localip, active;
             try {
                 ip = getStatValue(now, 'remoteAddress');
                 type = getStatValue(now, "transportType");
                 localip = getStatValue(now, "localAddress");
                 active = getStatValue(now, "activeConnection");
-            }            catch(e){/*not supported*/}
-            if(!ip || !type || !localip || active != "true")                {
+            } catch(e){/*not supported*/}
+            if(!ip || !type || !localip || active != "true") {
                 continue;
             }
             // Save the address unless it has been saved already.
         }
 
         if(now.type == "candidatepair") {
-            if(now.state == "succeeded")                {
+            if(now.state == "succeeded") {
                 continue;
             }
 
                 continue;
             }
         }
-        if (!packetsNow || packetsNow < 0)            {
+        if (!packetsNow || packetsNow < 0) {
             packetsNow = 0;
         }
 
                 (width = getStatValue(now, "googFrameWidthReceived"))) {
                 resolution.height = height;
                 resolution.width = width;
-            }            else if ((height = getStatValue(now, "googFrameHeightSent")) &&
+            } else if ((height = getStatValue(now, "googFrameHeightSent")) &&
                 (width = getStatValue(now, "googFrameWidthSent"))) {
                 resolution.height = height;
                 resolution.width = width;
             }
-        }        catch(e){/*not supported*/}
+        } catch(e){/*not supported*/}
 
         if (resolution.height && resolution.width) {
             ssrcStats.setResolution(resolution);
     for (var idx in this.currentAudioLevelsReport) {
         var now = this.currentAudioLevelsReport[idx];
 
-        if (now.type != 'ssrc')            {
+        if (now.type != 'ssrc') {
             continue;
         }
 
         }
 
         if (!ssrc) {
-            if ((Date.now() - now.timestamp) < 3000)                {
+            if ((Date.now() - now.timestamp) < 3000) {
                 logger.warn("No ssrc: ");
             }
             continue;
             var audioLevel
                 = getStatValue(now, 'audioInputLevel')
                     || getStatValue(now, 'audioOutputLevel');
-        }        catch(e) {/*not supported*/
+        } catch(e) {/*not supported*/
             logger.warn("Audio Levels are not available in the statistics.");
             clearInterval(this.audioLevelsIntervalId);
             return;

modules/statistics/statistics.js

             // of callstats.io may be disabled because of globally-disallowed
             // requests to any third parties.
             && (Statistics.disableThirdPartyRequests !== true);
-    if(this.callStatsIntegrationEnabled)        {
+    if(this.callStatsIntegrationEnabled) {
         loadCallStatsAPI(this.options.callStatsCustomScriptUrl);
     }
     this.callStats = null;
 Statistics.localStats = [];
 
 Statistics.startLocalStats = function (stream, callback) {
-    if(!Statistics.audioLevelsEnabled)        {
+    if(!Statistics.audioLevelsEnabled) {
         return;
     }
     var localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
 };
 
 Statistics.prototype.addAudioLevelListener = function(listener) {
-    if(!Statistics.audioLevelsEnabled)        {
+    if(!Statistics.audioLevelsEnabled) {
         return;
     }
     this.eventEmitter.on(StatisticsEvents.AUDIO_LEVEL, listener);
 };
 
 Statistics.prototype.removeAudioLevelListener = function(listener) {
-    if(!Statistics.audioLevelsEnabled)        {
+    if(!Statistics.audioLevelsEnabled) {
         return;
     }
     this.eventEmitter.removeListener(StatisticsEvents.AUDIO_LEVEL, listener);
     }
     this.stopCallStats();
     this.stopRemoteStats();
-    if(this.eventEmitter)        {
+    if(this.eventEmitter) {
         this.eventEmitter.removeAllListeners();
     }
 };
 
 Statistics.stopLocalStats = function (stream) {
-    if(!Statistics.audioLevelsEnabled)        {
+    if(!Statistics.audioLevelsEnabled) {
         return;
     }
 
-    for(var i = 0; i < Statistics.localStats.length; i++)        {
+    for(var i = 0; i < Statistics.localStats.length; i++) {
         if(Statistics.localStats[i].stream === stream){
             var localStats = Statistics.localStats.splice(i, 1);
             localStats[0].stop();
 Statistics.prototype.stopCallStats = function () {
     if(this.callStatsStarted) {
         var index = Statistics.callsStatsInstances.indexOf(this.callstats);
-        if(index > -1)            {
+        if(index > -1) {
             Statistics.callsStatsInstances.splice(index, 1);
         }
         // The next line is commented because we need to be able to send
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendIceConnectionFailedEvent = function (pc) {
-    if(this.callstats)        {
+    if(this.callstats) {
         this.callstats.sendIceConnectionFailedEvent(pc, this.callstats);
     }
     Statistics.analytics.sendEvent('connection.ice_failed');
  * @param type {String} "audio"/"video"
  */
 Statistics.prototype.sendMuteEvent = function (muted, type) {
-    if(this.callstats)        {
+    if(this.callstats) {
         CallStats.sendMuteEvent(muted, type, this.callstats);
     }
 };
  * false for not stopping
  */
 Statistics.prototype.sendScreenSharingEvent = function (start) {
-    if(this.callstats)        {
+    if(this.callstats) {
         CallStats.sendScreenSharingEvent(start, this.callstats);
     }
 };
  * conference.
  */
 Statistics.prototype.sendDominantSpeakerEvent = function () {
-    if(this.callstats)        {
+    if(this.callstats) {
         CallStats.sendDominantSpeakerEvent(this.callstats);
     }
 };
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendCreateOfferFailed = function (e, pc) {
-    if(this.callstats)        {
+    if(this.callstats) {
         CallStats.sendCreateOfferFailed(e, pc, this.callstats);
     }
 };
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendCreateAnswerFailed = function (e, pc) {
-    if(this.callstats)        {
+    if(this.callstats) {
         CallStats.sendCreateAnswerFailed(e, pc, this.callstats);
     }
 };
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendSetLocalDescFailed = function (e, pc) {
-    if(this.callstats)        {
+    if(this.callstats) {
         CallStats.sendSetLocalDescFailed(e, pc, this.callstats);
     }
 };
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendSetRemoteDescFailed = function (e, pc) {
-    if(this.callstats)        {
+    if(this.callstats) {
         CallStats.sendSetRemoteDescFailed(e, pc, this.callstats);
     }
 };
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendAddIceCandidateFailed = function (e, pc) {
-    if(this.callstats)        {
+    if(this.callstats) {
         CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);
     }
 };
  * @param detailed detailed feedback from the user. Not yet used
  */
 Statistics.prototype.sendFeedback = function(overall, detailed) {
-    if(this.callstats)        {
+    if(this.callstats) {
         this.callstats.sendFeedback(overall, detailed);
     }
     Statistics.analytics.sendEvent("feedback.rating",

modules/transcription/audioRecorder.js

  * Possible audio formats MIME types
  */
 var AUDIO_WEBM = "audio/webm";    // Supported in chrome
-var AUDIO_OGG  = "audio/ogg";     // Supported in firefox
+var AUDIO_OGG = "audio/ogg";     // Supported in firefox
 
 /**
  * A TrackRecorder object holds all the information needed for recording a
 function determineCorrectFileType() {
     if(MediaRecorder.isTypeSupported(AUDIO_WEBM)) {
         return AUDIO_WEBM;
-    }    else if(MediaRecorder.isTypeSupported(AUDIO_OGG)) {
+    } else if(MediaRecorder.isTypeSupported(AUDIO_OGG)) {
         return AUDIO_OGG;
-    }    else {
+    } else {
         throw new Error("unable to create a MediaRecorder with the" +
             "right mimetype!");
     }
             var recorderToRemove = array[i];
             if(this.isRecording){
                 stopRecorder(recorderToRemove);
-            }            else {
+            } else {
                 //remove the TrackRecorder from the array
                 array.splice(i, 1);
             }
     this.recorders.forEach(function(trackRecorder){
         if(trackRecorder.track.isLocal()){
             trackRecorder.name = "the transcriber";
-        }        else {
+        } else {
             var id = trackRecorder.track.getParticipantId();
             var participant = conference.getParticipantById(id);
             var newName = participant.getDisplayName();
     // Firefox supports the MediaStream object, Chrome webkitMediaStream
     if(typeof MediaStream !== 'undefined') {
         return new MediaStream();
-    }    else if(typeof webkitMediaStream !== 'undefined') {
+    } else if(typeof webkitMediaStream !== 'undefined') {
         return new webkitMediaStream(); // eslint-disable-line new-cap
-    }    else {
+    } else {
         throw new Error("cannot create a clean mediaStream");
     }
 }

modules/transcription/transcriber.js

     //the object which can record all audio in the conference
     this.audioRecorder = new AudioRecorder();
     //this object can send the recorder audio to a speech-to-text service
-    this.transcriptionService =  new SphinxService();
+    this.transcriptionService = new SphinxService();
     //holds a counter to keep track if merging can start
     this.counter = null;
     //holds the date when transcription started which makes it possible
     this.transcription = null;
     //this will be a method which will be called once the transcription is done
     //with the transcription as parameter
-    this.callback =  null;
+    this.callback = null;
     //stores all the retrieved speech-to-text results to merge together
     //this value will store an Array<Word> object
     this.results = [];
 var pushWordToSortedArray = function(array, word){
     if(array.length === 0) {
         array.push(word);
-    }    else{
+    } else{
         if(array[array.length - 1].begin <= word.begin){
             array.push(word);
             return;

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

                    " is not valid!");
             recordingResult.wordArray = [];
             callback(recordingResult);
-        }        else{
+        } else{
             recordingResult.wordArray = t.formatResponse(response);
             callback(recordingResult);
         }

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

     var json;
     try{
         json = JSON.parse(response);
-    }    catch (error){
+    } catch (error){
         console.log(error);
         return false;
     }
     "Sphinx4 https server";
     if(config.sphinxURL === undefined){
         console.log(message);
-    }    else {
+    } else {
         var toReturn = config.sphinxURL;
         if(toReturn.includes !== undefined && toReturn.includes("https://")){
             return toReturn;
-        }        else{
+        } else{
             console.log(message);
         }
     }

modules/util/EventEmitterForwarder.js

  */
 function EventEmitterForwarder (src, dest) {
     if (!src || !dest || typeof src.addListener !== "function" ||
-        typeof dest.emit !== "function")        {
+        typeof dest.emit !== "function") {
         throw new Error("Invalid arguments passed to EventEmitterForwarder");
     }
     this.src = src;

modules/util/GlobalOnErrorHandler.js

     handlers.forEach(function (handler) {
         handler(message, source, lineno, colno, error);
     });
-    if (oldOnErrorHandler)        {
+    if (oldOnErrorHandler) {
         oldOnErrorHandler(message, source, lineno, colno, error);
     }
 }
     handlers.forEach(function (handler) {
         handler(null, null, null, null, event.reason);
     });
-    if(oldOnUnhandledRejection)        {
+    if(oldOnUnhandledRejection) {
         oldOnUnhandledRejection(event);
     }
 }
      */
     callErrorHandler: function (error) {
         var errHandler = window.onerror;
-        if(!errHandler)            {
+        if(!errHandler) {
             return;
         }
         errHandler(null, null, null, null, error);
      */
     callUnhandledRejectionHandler: function (error) {
         var errHandler = window.onunhandledrejection;
-        if(!errHandler)            {
+        if(!errHandler) {
             return;
         }
         errHandler(error);

modules/util/ScriptUtil.js

                 var scriptSrc = scriptEl.src;
                 var baseScriptSrc
                     = scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);
-                if (scriptSrc && baseScriptSrc)                    {
+                if (scriptSrc && baseScriptSrc) {
                     src = baseScriptSrc + src;
                 }
             }
         }
 
-        if (loadCallback)            {
+        if (loadCallback) {
             script.onload = loadCallback;
         }
-        if (errorCallback)            {
+        if (errorCallback) {
             script.onerror = errorCallback;
         }
 

modules/util/UsernameGenerator.js

     var name = RandomUtil.randomElement(names);
     var suffix = RandomUtil.randomAlphanumStr(3);
 
-    return name + '-' +  suffix;
+    return name + '-' + suffix;
 }
 
 module.exports = {

modules/version/ComponentsVersions.js

         }.bind(this));
 
     // logs versions to stats
-        if (log.length > 0)        {
+        if (log.length > 0) {
             Statistics.sendLog(JSON.stringify(log));
         }
     };

modules/xmpp/Caps.js

     getFeatures(jid, timeout = 5000) {
         const user
             = jid in this.jidToVersion ? this.jidToVersion[jid] : null;
-        if(!user || !(user.version in this.versionToCapabilities))        {
+        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 => {

modules/xmpp/ChatRoom.js

                 continue;
             }
             packet.c(node.tagName, node.attributes);
-            if(node.value)                {
+            if(node.value) {
                 packet.t(node.value);
             }
-            if(node.children)                {
+            if(node.children) {
                 this.json2packet(node.children, packet);
             }
             packet.up();
  */
 function filterNodeFromPresenceJSON(pres, nodeName){
     var res = [];
-    for(let i = 0; i < pres.length; i++)        {
-        if(pres[i].tagName === nodeName)            {
+    for(let i = 0; i < pres.length; i++) {
+        if(pres[i].tagName === nodeName) {
             res.push(pres[i]);
         }
     }
         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++)        {
+        for(let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
-            switch(node.tagName)            {
+            switch(node.tagName) {
             case "nick":
                 member.nick = node.value;
                 break;
                 logger.log("(TIME) MUC joined:\t", now);
 
                 // set correct initial state of locked
-                if (this.password)                    {
+                if (this.password) {
                     this.locked = true;
                 }
 
             }
 
             // store the new display name
-            if(member.displayName)                {
+            if(member.displayName) {
                 memberOfThis.displayName = member.displayName;
             }
         }
 
         // after we had fired member or room joined events, lets fire events
         // for the rest info we got in presence
-        for(let i = 0; i < nodes.length; i++)        {
+        for(let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
-            switch(node.tagName)            {
+            switch(node.tagName) {
             case "nick":
                 if(!member.isFocus) {
                     var displayName = this.xmpp.options.displayJids
                 break;
             case "call-control":
                 var att = node.attributes;
-                if(!att)                        {
+                if(!att) {
                     break;
                 }
                 this.phoneNumber = att.phone || null;
             this.eventEmitter.emit(XMPPEvents.PRESENCE_STATUS, from, member.status);
         }
 
-        if(jibri)        {
+        if(jibri) {
             this.lastJibri = jibri;
-            if(this.recording)                {
+            if(this.recording) {
                 this.recording.handleJibriPresence(jibri);
             }
         }
             this.recording = new Recorder(this.options.recordingType,
                 this.eventEmitter, this.connection, this.focusMucJid,
                 this.options.jirecon, this.roomjid);
-            if(this.lastJibri)                {
+            if(this.lastJibri) {
                 this.recording.handleJibriPresence(this.lastJibri);
             }
         }
 
         delete this.lastPresences[jid];
 
-        if(skipEvents)            {
+        if(skipEvents) {
             return;
         }
 
 
             // we fire muc_left only if this is not a kick,
             // kick has both statuses 110 and 307.
-            if (!isKick)                {
+            if (!isKick) {
                 this.eventEmitter.emit(XMPPEvents.MUC_LEFT);
             }
         }
 
     setVideoMute (mute, callback) {
         this.sendVideoInfoPresence(mute);
-        if(callback)            {
+        if(callback) {
             callback(mute);
         }
     }
                 value: mute.toString()});
     }
 
-    sendAudioInfoPresence  (mute, callback) {
+    sendAudioInfoPresence (mute, callback) {
         this.addAudioInfoToPresence(mute);
         if(this.connection) {
             this.sendPresence();
         }
-        if(callback)            {
+        if(callback) {
             callback();
         }
     }
 
     sendVideoInfoPresence (mute) {
         this.addVideoInfoToPresence(mute);
-        if(!this.connection)            {
+        if(!this.connection) {
             return;
         }
         this.sendPresence();
      * Returns true if the recording is supproted and false if not.
      */
     isRecordingSupported () {
-        if(this.recording)            {
+        if(this.recording) {
             return this.recording.isSupported();
         }
         return false;
      * @param statusChangeHandler {function} receives the new status as argument.
      */
     toggleRecording (options, statusChangeHandler) {
-        if(this.recording)            {
+        if(this.recording) {
             return this.recording.toggleRecording(options, statusChangeHandler);
         }
 
      * Returns true if the SIP calls are supported and false otherwise
      */
     isSIPCallingSupported () {
-        if(this.moderator)            {
+        if(this.moderator) {
             return this.moderator.isSipGatewayEnabled();
         }
         return false;

modules/xmpp/JingleSessionPC.js

                 if (typeof protocol === 'string') {
                     protocol = protocol.toLowerCase();
                     if (protocol === 'tcp' || protocol === 'ssltcp') {
-                        if (this.webrtcIceTcpDisable)                            {
+                        if (this.webrtcIceTcpDisable) {
                             return;
                         }
                     } else if (protocol == 'udp') {
-                        if (this.webrtcIceUdpDisable)                            {
+                        if (this.webrtcIceUdpDisable) {
                             return;
                         }
                     }
 
                 break;
             case 'disconnected':
-                if (this.closed)                        {
+                if (this.closed) {
                     break;
                 }
                 this.isreconnect = true;
                     // Informs interested parties that the connection has been
                     // interrupted.
-                if (this.wasstable)                        {
+                if (this.wasstable) {
                     this.room.eventEmitter.emit(
                             XMPPEvents.CONNECTION_INTERRUPTED);
                 }
                 }
                 $(this).find('>parameter').each(function () {
                     lines += 'a=ssrc:' + ssrc + ' ' + $(this).attr('name');
-                    if ($(this).attr('value') && $(this).attr('value').length)                        {
+                    if ($(this).attr('value') && $(this).attr('value').length) {
                         lines += ':' + $(this).attr('value');
                     }
                     lines += '\r\n';
                 });
             });
             currentRemoteSdp.media.forEach(function(media, idx) {
-                if (!SDPUtil.find_line(media, 'a=mid:' + name))                    {
+                if (!SDPUtil.find_line(media, 'a=mid:' + name)) {
                     return;
                 }
                 if (!addSsrcInfo[idx]) {
                 ssrcs.push(ssrc);
             });
             currentRemoteSdp.media.forEach(function(media, idx) {
-                if (!SDPUtil.find_line(media, 'a=mid:' + name))                    {
+                if (!SDPUtil.find_line(media, 'a=mid:' + name)) {
                     return;
                 }
                 if (!removeSsrcInfo[idx]) {
             if (errorElSel.length) {
                 error.code = errorElSel.attr('code');
                 const errorReasonSel = $(errResponse).find('error :first');
-                if (errorReasonSel.length)                    {
+                if (errorReasonSel.length) {
                     error.reason = errorReasonSel[0].tagName;
                 }
             }
             ssrcs.forEach(function (ssrcObj) {
                 const desc = $(jingle.tree()).find(">jingle>content[name=\"" +
                     ssrcObj.mtype + "\"]>description");
-                if (!desc || !desc.length)                    {
+                if (!desc || !desc.length) {
                     return;
                 }
                 ssrcObj.ssrcs.forEach(function (ssrc) {
     fixSourceRemoveJingle(jingle) {
         let ssrcs = this.modifiedSSRCs["mute"];
         this.modifiedSSRCs["mute"] = [];
-        if (ssrcs && ssrcs.length)            {
+        if (ssrcs && ssrcs.length) {
             ssrcs.forEach(function (ssrcObj) {
                 ssrcObj.ssrcs.forEach(function (ssrc) {
                     const sourceNode
 
         ssrcs = this.modifiedSSRCs["remove"];
         this.modifiedSSRCs["remove"] = [];
-        if (ssrcs && ssrcs.length)            {
+        if (ssrcs && ssrcs.length) {
             ssrcs.forEach(function (ssrcObj) {
                 const desc
                     = JingleSessionPC.createDescriptionNode(

modules/xmpp/RtxModifier.js

 /* global __filename */
 
 import { getLogger } from "jitsi-meet-logger";
-import { parseSecondarySSRC, SdpTransformWrap  } from './SdpTransformUtil';
+import { parseSecondarySSRC, SdpTransformWrap } from './SdpTransformUtil';
 import * as SDPUtil from "./SDPUtil";
 
 const logger = getLogger(__filename);

modules/xmpp/SDP.js

     var medias = this.getMediaSsrcMap();
     var result = false;
     Object.keys(medias).forEach(function (mediaindex) {
-        if (result)            {
+        if (result) {
             return;
         }
         if (medias[mediaindex].ssrcs[ssrc]) {
         lines = this.media[i].split('\r\n');
         lines.pop(); // remove empty last element
         mline = SDPUtil.parse_mline(lines.shift());
-        if (mline.media != 'audio')            {
+        if (mline.media != 'audio') {
             continue;
         }
         newdesc = '';
         for (j = 0; j < lines.length; j++) {
             if (lines[j].substr(0, 9) == 'a=rtpmap:') {
                 rtpmap = SDPUtil.parse_rtpmap(lines[j]);
-                if (rtpmap.name == 'CN' || rtpmap.name == 'ISAC')                    {
+                if (rtpmap.name == 'CN' || rtpmap.name == 'ISAC') {
                     continue;
                 }
                 mline.fmt.push(rtpmap.id);
             protocol: sctpAttrs[1] /* protocol */
         });
         // Optional stream count attribute
-        if (sctpAttrs.length > 2)            {
+        if (sctpAttrs.length > 2) {
             elem.attrs({ streams: sctpAttrs[2]});
         }
         elem.up();
             ' ' + sctp.attr('protocol');
 
         var streamCount = sctp.attr('streams');
-        if (streamCount)            {
+        if (streamCount) {
             media += ' ' + streamCount + '\r\n';
-        }        else            {
+        } else {
             media += '\r\n';
         }
     }
 
     media += 'c=IN IP4 0.0.0.0\r\n';
-    if (!sctp.length)        {
+    if (!sctp.length) {
         media += 'a=rtcp:1 IN IP4 0.0.0.0\r\n';
     }
     tmp = content.find('>transport[xmlns="urn:xmpp:jingle:transports:ice-udp:1"]');
                 && (protocol === 'tcp' || protocol === 'ssltcp')) ||
             (self.removeUdpCandidates && protocol === 'udp')) {
             return;
-        } else  if (self.failICE) {
+        } else if (self.failICE) {
             this.setAttribute('ip', '1.1.1.1');
         }
 
             var value = this.getAttribute('value');
             value = SDPUtil.filter_special_chars(value);
             media += 'a=ssrc:' + ssrc + ' ' + name;
-            if (value && value.length)                {
+            if (value && value.length) {
                 media += ':' + value;
             }
             media += '\r\n';

modules/xmpp/SDPDiffer.js

     // this could be useful in Array.prototype.
     function arrayEquals(array) {
         // if the other array is a falsy value, return
-        if (!array)            {
+        if (!array) {
             return false;
         }
 
         // compare lengths - can save a lot of time
-        if (this.length != array.length)            {
+        if (this.length != array.length) {
             return false;
         }
 
             // Check if we have nested arrays
             if (this[i] instanceof Array && array[i] instanceof Array) {
                 // recurse into the nested arrays
-                if (!this[i].equals(array[i]))                    {
+                if (!this[i].equals(array[i])) {
                     return false;
                 }
-            }            else if (this[i] != array[i]) {
+            } else if (this[i] != array[i]) {
                 // Warning - two different object instances will never be
                 // equal: {x:20} != {x:20}
                 return false;

modules/xmpp/SDPUtil.js

      * @param line eg. "a=sctpmap:5000 webrtc-datachannel"
      * @returns [SCTP port number, protocol, streams]
      */
-    parse_sctpmap: function (line)    {
+    parse_sctpmap: function (line) {
         var parts = line.substring(10).split(' ');
         var sctpPort = parts[0];
         var protocol = parts[1];
         var lines = haystack.split('\r\n'),
             needles = [];
         for (var i = 0; i < lines.length; i++) {
-            if (lines[i].substring(0, needle.length) == needle)                {
+            if (lines[i].substring(0, needle.length) == needle) {
                 needles.push(lines[i]);
             }
         }

modules/xmpp/moderator.js

     }
 }
 
-Moderator.prototype.isExternalAuthEnabled =  function () {
+Moderator.prototype.isExternalAuthEnabled = function () {
     return this.externalAuthEnabled;
 };
 
-Moderator.prototype.isSipGatewayEnabled =  function () {
+Moderator.prototype.isSipGatewayEnabled = function () {
     return this.sipGatewayEnabled;
 };
 
 
-Moderator.prototype.onMucMemberLeft =  function (jid) {
+Moderator.prototype.onMucMemberLeft = function (jid) {
     logger.info("Someone left is it focus ? " + jid);
     var resource = Strophe.getResourceFromJid(jid);
     if (resource === 'focus') {
 };
 
 
-Moderator.prototype.setFocusUserJid =  function (focusJid) {
+Moderator.prototype.setFocusUserJid = function (focusJid) {
     if (!this.focusUserJid) {
         this.focusUserJid = focusJid;
         logger.info("Focus jid set to:  " + this.focusUserJid);
 };
 
 
-Moderator.prototype.getFocusUserJid =  function () {
+Moderator.prototype.getFocusUserJid = function () {
     return this.focusUserJid;
 };
 
-Moderator.prototype.getFocusComponent =  function () {
+Moderator.prototype.getFocusComponent = function () {
     // Get focus component address
     var focusComponent = this.options.connection.hosts.focus;
     // If not specified use default:  'focus.domain'
     return focusComponent;
 };
 
-Moderator.prototype.createConferenceIq =  function () {
+Moderator.prototype.createConferenceIq = function () {
     // Generate create conference IQ
     var elem = $iq({to: this.getFocusComponent(), type: 'set'});
 
 };
 
 
-Moderator.prototype.parseSessionId =  function (resultIq) {
+Moderator.prototype.parseSessionId = function (resultIq) {
     var sessionId = $(resultIq).find('conference').attr('session-id');
     if (sessionId) {
         logger.info('Received sessionId:  ' + sessionId);
     }
 };
 
-Moderator.prototype.parseConfigOptions =  function (resultIq) {
+Moderator.prototype.parseConfigOptions = function (resultIq) {
 
     this.setFocusUserJid(
         $(resultIq).find('conference').attr('focusjid'));
  * @param {Function} callback - the function to be called back upon the
  * successful allocation of the conference focus
  */
-Moderator.prototype.allocateConferenceFocus =  function (callback) {
+Moderator.prototype.allocateConferenceFocus = function (callback) {
     // Try to use focus user JID from the config
     this.setFocusUserJid(this.options.connection.focusUserJid);
     // Send create conference IQ
     this._getLoginUrl(/* popup */ true, urlCallback, failureCallback);
 };
 
-Moderator.prototype.logout =  function (callback) {
+Moderator.prototype.logout = function (callback) {
     var iq = $iq({to: this.getFocusComponent(), type: 'set'});
     var sessionId = Settings.getSessionId();
     if (!sessionId) {

modules/xmpp/recording.js

     this.url = null;
     this.type = type;
     this._isSupported
-        =  type === Recording.types.JIRECON && !this.jirecon
+        = type === Recording.types.JIRECON && !this.jirecon
             || (type !== Recording.types.JIBRI
                 && type !== Recording.types.COLIBRI)
             ? false : true;
 
 Recording.prototype.handleJibriPresence = function (jibri) {
     var attributes = jibri.attributes;
-    if(!attributes)        {
+    if(!attributes) {
         return;
     }
 
     var newState = attributes.status;
     logger.log("Handle jibri presence : ", newState);
 
-    if (newState === this.state)        {
+    if (newState === this.state) {
         return;
     }
 
     if (newState === "undefined") {
         this.state = Recording.status.UNAVAILABLE;
-    }    else if (newState === "off") {
+    } else if (newState === "off") {
         if (!this.state
             || this.state === "undefined"
-            || this.state === Recording.status.UNAVAILABLE)            {
+            || this.state === Recording.status.UNAVAILABLE) {
             this.state = Recording.status.AVAILABLE;
-        }        else            {
+        } else {
             this.state = Recording.status.OFF;
         }
-    }    else {
+    } else {
         this.state = newState;
     }
 
 
     // If the recorder is currently unavailable we throw an error.
     if (oldState === Recording.status.UNAVAILABLE
-        || oldState === Recording.status.FAILED)        {
+        || oldState === Recording.status.FAILED) {
         statusChangeHandler(Recording.status.FAILED,
                             JitsiRecorderErrors.RECORDER_UNAVAILABLE);
-    }    else if (oldState === Recording.status.BUSY)        {
+    } else if (oldState === Recording.status.BUSY) {
         statusChangeHandler(Recording.status.BUSY,
                             JitsiRecorderErrors.RECORDER_BUSY);
     }

modules/xmpp/strophe.emuc.js

         }
 
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
-        if(!room)            {
+        if(!room) {
             return;
         }
 
     onPresenceUnavailable (pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
-        if(!room)            {
+        if(!room) {
             return;
         }
 
     onPresenceError (pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
-        if(!room)            {
+        if(!room) {
             return;
         }
 
         // 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)            {
+        if(!room) {
             return;
         }
 
     onMute(iq) {
         const from = iq.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
-        if(!room)            {
+        if(!room) {
             return;
         }
 

modules/xmpp/xmpp.js

             this.connection.ping.hasPingSupport(
                 pingJid,
                 function (hasPing) {
-                    if (hasPing)                        {
+                    if (hasPing) {
                         this.connection.ping.startInterval(pingJid);
-                    }                    else                        {
+                    } else {
                         logger.warn("Ping NOT supported by " + pingJid);
                     }
                 }.bind(this));
 
-            if (password)                {
+            if (password) {
                 this.authenticatedUser = true;
             }
             if (this.connection && this.connection.connected &&
     createRoom (roomName, options) {
         // By default MUC nickname is the resource part of the JID
         let mucNickname = Strophe.getNodeFromJid(this.connection.jid);
-        let roomjid = roomName  + "@" + this.options.hosts.muc + "/";
+        let roomjid = roomName + "@" + this.options.hosts.muc + "/";
         const cfgNickname
             = options.useNicks && options.nick ? options.nick : null;