fix(eslint): Add brace-style rule

.eslintrc.js

         'consistent-return': 0,
         'curly': 2,
 
+        // Stylistic issues group
+        'brace-style': 2,
+
         'prefer-const': 2,
         'prefer-reflect': 0,
         'prefer-spread': 2,

JitsiConference.js

  * @param connection {JitsiConnection} overrides this.connection
  */
 JitsiConference.prototype._init = function (options) {
-    if (!options)
-        {options = {};}
+    if (!options)        {
+options = {};
+}
 
     // Override connection and xmpp properties (Usefull if the connection
     // reloaded)
  * @param password {string} the password
  */
 JitsiConference.prototype.join = function (password) {
-    if (this.room)
-        {this.room.join(password);}
+    if (this.room)        {
+this.room.join(password);
+}
 };
 
 /**
     this.getLocalTracks().forEach(track => this.onLocalTrackRemoved(track));
 
     this.rtc.closeAllDataChannels();
-    if (this.statistics)
-        {this.statistics.dispose();}
+    if (this.statistics)        {
+this.statistics.dispose();
+}
 
     // leave the conference
     if (this.room) {
  * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
  */
 JitsiConference.prototype.on = function (eventId, handler) {
-    if (this.eventEmitter)
-        {this.eventEmitter.on(eventId, handler);}
+    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)
-        {this.eventEmitter.removeListener(eventId, handler);}
+    if (this.eventEmitter)        {
+this.eventEmitter.removeListener(eventId, handler);
+}
 };
 
 // Common aliases for event emitter
  * @param handler {Function} handler for the command
  */
  JitsiConference.prototype.addCommandListener = function (command, handler) {
-    if (this.room)
-        {this.room.addPresenceListener(command, handler);}
+    if (this.room)        {
+this.room.addPresenceListener(command, handler);
+}
  };
 
 /**
   * @param command {String} the name of the command
   */
  JitsiConference.prototype.removeCommandListener = function (command) {
-    if (this.room)
-        {this.room.removePresenceListener(command);}
+    if (this.room)        {
+this.room.removePresenceListener(command);
+}
  };
 
 /**
  * @param message the text message.
  */
 JitsiConference.prototype.sendTextMessage = function (message) {
-    if (this.room)
-        {this.room.sendMessage(message);}
+    if (this.room)        {
+this.room.sendMessage(message);
+}
 };
 
 /**
  * @param name {String} the name of the command.
  **/
 JitsiConference.prototype.removeCommand = function (name) {
-    if (this.room)
-        {this.room.removeFromPresence(name);}
+    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)
-        {this.statistics.sendScreenSharingEvent(false);}
+    if (track.isVideoTrack() && track.videoType === VideoType.DESKTOP)        {
+this.statistics.sendScreenSharingEvent(false);
+}
 
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
 };
     // 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)
-        {this.statistics.sendScreenSharingEvent(true);}
+    if (newTrack.isVideoTrack() && newTrack.videoType === VideoType.DESKTOP)        {
+this.statistics.sendScreenSharingEvent(true);
+}
 
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, newTrack);
 };
     }.bind(this));
 
     // there can be no participant in case the member that left is focus
-    if (participant)
-        {this.eventEmitter.emit(
-            JitsiConferenceEvents.USER_LEFT, id, participant);}
+    if (participant)        {
+this.eventEmitter.emit(
+            JitsiConferenceEvents.USER_LEFT, id, participant);
+}
 };
 
 JitsiConference.prototype.onUserRoleChanged = function (jid, role) {
         return;
     }
 
-    if (participant._displayName === displayName)
-        {return;}
+    if (participant._displayName === displayName)        {
+return;
+}
 
     participant._displayName = displayName;
     this.eventEmitter.emit(JitsiConferenceEvents.DISPLAY_NAME_CHANGED, id, displayName);
  * Returns true if recording is supported and false if not.
  */
 JitsiConference.prototype.isRecordingSupported = function () {
-    if (this.room)
-        {return this.room.isRecordingSupported();}
+    if (this.room)        {
+return this.room.isRecordingSupported();
+}
     return false;
 };
 
  * Starts/stops the recording
  */
 JitsiConference.prototype.toggleRecording = function (options) {
-    if (this.room)
-        {return this.room.toggleRecording(options, function (status, error) {
+    if (this.room)        {
+return this.room.toggleRecording(options, function (status, error) {
             this.eventEmitter.emit(
                 JitsiConferenceEvents.RECORDER_STATE_CHANGED, status, error);
-        }.bind(this));}
+        }.bind(this));
+}
     this.eventEmitter.emit(
         JitsiConferenceEvents.RECORDER_STATE_CHANGED, "error",
         new Error("The conference is not created yet!"));
  * Returns true if the SIP calls are supported and false otherwise
  */
 JitsiConference.prototype.isSIPCallingSupported = function () {
-    if (this.room)
-        {return this.room.isSIPCallingSupported();}
+    if (this.room)        {
+return this.room.isSIPCallingSupported();
+}
     return false;
 };
 
  * @param number the number
  */
 JitsiConference.prototype.dial = function (number) {
-    if (this.room)
-        {return this.room.dial(number);}
+    if (this.room)        {
+return this.room.dial(number);
+}
     return new Promise(function(resolve, reject){
-        reject(new Error("The conference is not created yet!"));});
+        reject(new Error("The conference is not created yet!"));
+});
 };
 
 /**
  * Hangup an existing call
  */
 JitsiConference.prototype.hangup = function () {
-    if (this.room)
-        {return this.room.hangup();}
+    if (this.room)        {
+return this.room.hangup();
+}
     return new Promise(function(resolve, reject){
-        reject(new Error("The conference is not created yet!"));});
+        reject(new Error("The conference is not created yet!"));
+});
 };
 
 /**
  * Returns the phone number for joining the conference.
  */
 JitsiConference.prototype.getPhoneNumber = function () {
-    if (this.room)
-        {return this.room.getPhoneNumber();}
+    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)
-        {return this.room.getPhonePin();}
+    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)
-                {return;}
+            if(!track.isLocal() || !conference.statistics)                {
+return;
+}
             conference.statistics.sendMuteEvent(track.isMuted(),
                 track.getType());
         });
  */
 JitsiConferenceEventManager.prototype.setupStatisticsListeners = function () {
     var conference = this.conference;
-    if(!conference.statistics)
-        {return;}
+    if(!conference.statistics)        {
+return;
+}
 
     conference.statistics.addAudioLevelListener(function (ssrc, level) {
         var resource = conference.rtc.getResourceBySSRC(ssrc);
-        if (!resource)
-            {return;}
+        if (!resource)            {
+return;
+}
 
         conference.rtc.setAudioLevel(resource, level);
     });
     conference.statistics.addByteSentStatsListener(function (stats) {
         conference.getLocalTracks(MediaType.AUDIO).forEach(function (track) {
             const ssrc = track.getSSRC();
-            if (!ssrc || !stats.hasOwnProperty(ssrc))
-                {return;}
+            if (!ssrc || !stats.hasOwnProperty(ssrc))                {
+return;
+}
 
             track._setByteSent(stats[ssrc]);
         });

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)
-                {Statistics.analytics.sendEvent(
-                    'connection.disconnected.' + msg);}
+            if(msg)                {
+Statistics.analytics.sendEvent(
+                    'connection.disconnected.' + msg);
+}
             Statistics.sendLog(
                 JSON.stringify({id: "connection.disconnected", msg: msg}));
         });
  * (for example authentications parameters).
  */
 JitsiConnection.prototype.connect = function (options) {
-    if(!options)
-        {options = {};}
+    if(!options)        {
+options = {};
+}
 
     this.xmpp.connect(options.id, options.password);
 };

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])
-        {return null;}
+    if(!Resolutions[resolution])        {
+return null;
+}
     var order = Resolutions[resolution].order;
     var res = null;
     var resName = null;
             }, USER_MEDIA_PERMISSION_PROMPT_TIMEOUT);
         }
 
-        if(!window.connectionTimes)
-            {window.connectionTimes = {};}
+        if(!window.connectionTimes)            {
+window.connectionTimes = {};
+}
         window.connectionTimes["obtainPermissions.start"] =
             window.performance.now();
 
                 Statistics.analytics.sendEvent(addDeviceTypeToAnalyticsEvent(
                     "getUserMedia.success", options), {value: options});
 
-                if(!RTC.options.disableAudioLevels)
-                    {for(let i = 0; i < tracks.length; i++) {
+                if(!RTC.options.disableAudioLevels)                    {
+for(let i = 0; i < tracks.length; i++) {
                         const track = tracks[i];
                         var mStream = track.getOriginalStream();
                         if(track.getType() === MediaType.AUDIO){
                                     Statistics.stopLocalStats(mStream);
                                 });
                         }
-                    }}
+                    }
+}
 
                 // set real device ids
                 var currentlyAvailableMediaDevices

doc/example/example.js

  * Handles local tracks.
  * @param tracks Array with JitsiTrack objects
  */
-function onLocalTracks(tracks)
-{
+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)
-            {room.addTrack(localTracks[i]);}
+        if(isJoined)            {
+room.addTrack(localTracks[i]);
+}
     }
 }
 
  * @param track JitsiTrack object
  */
 function onRemoteTrack(track) {
-    if(track.isLocal())
-        {return;}
+    if(track.isLocal())        {
+return;
+}
     var participant = track.getParticipantId();
-    if(!remoteTracks[participant])
-        {remoteTracks[participant] = [];}
+    if(!remoteTracks[participant])        {
+remoteTracks[participant] = [];
+}
     var idx = remoteTracks[participant].push(track);
     track.addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
         function (audioLevel) {
 function onConferenceJoined () {
     console.log("conference joined!");
     isJoined = true;
-    for(var i = 0; i < localTracks.length; i++)
-        {room.addTrack(localTracks[i]);}
+    for(var i = 0; i < localTracks.length; i++)        {
+room.addTrack(localTracks[i]);
+}
 }
 
 function onUserLeft(id) {
     console.log("user left");
-    if(!remoteTracks[id])
-        {return;}
+    if(!remoteTracks[id])        {
+return;
+}
     var tracks = remoteTracks[id];
-    for(var i = 0; i< tracks.length; i++)
-        {tracks[i].detach($("#" + id + tracks[i].getType()));}
+    for(var i = 0; i< tracks.length; i++)        {
+tracks[i].detach($("#" + id + tracks[i].getType()));
+}
 }
 
 /**
         console.log("track removed!!!" + track);
     });
     room.on(JitsiMeetJS.events.conference.CONFERENCE_JOINED, onConferenceJoined);
-    room.on(JitsiMeetJS.events.conference.USER_JOINED, function(id){ console.log("user join");remoteTracks[id] = [];});
+    room.on(JitsiMeetJS.events.conference.USER_JOINED, function(id){
+ console.log("user join");remoteTracks[id] = [];
+});
     room.on(JitsiMeetJS.events.conference.USER_LEFT, onUserLeft);
     room.on(JitsiMeetJS.events.conference.TRACK_MUTE_CHANGED, function (track) {
         console.log(track.getType() + " - " + track.isMuted());
 }
 
 function unload() {
-    for(var i = 0; i < localTracks.length; i++)
-        {localTracks[i].stop();}
+    for(var i = 0; i < localTracks.length; i++)        {
+localTracks[i].stop();
+}
     room.leave();
     connection.disconnect();
 }
 
 if (JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
     JitsiMeetJS.mediaDevices.enumerateDevices(function(devices) {
-        var audioOutputDevices = devices.filter(function(d) { return d.kind === 'audiooutput'; });
+        var audioOutputDevices = devices.filter(function(d) {
+ return d.kind === 'audiooutput'; 
+});
 
         if (audioOutputDevices.length > 1) {
             $('#audioOutputSelect').html(

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)
-            {self._dataChannels = self._dataChannels.splice(idx, 1);}
+        if (idx > -1)            {
+self._dataChannels = self._dataChannels.splice(idx, 1);
+}
     };
     this._dataChannels.push(dataChannel);
 };
     var dataChannels = this._dataChannels;
 
     if (dataChannels && dataChannels.length !== 0) {
-        if (thisArg)
-            {return dataChannels.some(callback, thisArg);}
-        else
-            {return dataChannels.some(callback);}
+        if (thisArg)            {
+return dataChannels.some(callback, thisArg);
+}        else            {
+return dataChannels.some(callback);
+}
     } else {
         return false;
     }

modules/RTC/JitsiLocalTrack.js

     JitsiTrack.call(this,
         null /* RTC */, stream, track,
         function () {
-            if(!this.dontFireRemoveEvent)
-                {this.eventEmitter.emit(
-                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);}
+            if(!this.dontFireRemoveEvent)                {
+this.eventEmitter.emit(
+                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);
+}
             this.dontFireRemoveEvent = false;
         }.bind(this) /* inactiveHandler */,
         mediaType, videoType, null /* ssrc */);
 
     // 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())
-        {this.resolution = null;}
+    if (RTCBrowserType.isFirefox())        {
+this.resolution = null;
+}
 
     this.deviceId = deviceId;
     this.startMuted = false;
  */
 JitsiLocalTrack.prototype._onNoDataFromSourceError = function () {
     this._clearNoDataFromSourceMuteResources();
-    if(this._checkForCameraIssues())
-        {this._fireNoDataFromSourceEvent();}
+    if(this._checkForCameraIssues())        {
+this._fireNoDataFromSourceEvent();
+}
 };
 
 /**
     if (this.isAudioTrack() ||
         this.videoType === VideoType.DESKTOP ||
         RTCBrowserType.isFirefox()) {
-        if(this.track)
-            {this.track.enabled = !mute;}
+        if(this.track)            {
+this.track.enabled = !mute;
+}
     } else {
         if(mute) {
             this.dontFireRemoveEvent = true;
                 devices: [ MediaType.VIDEO ],
                 facingMode: this.getCameraFacingMode()
             };
-            if (this.resolution)
-                {streamOptions.resolution = this.resolution;}
+            if (this.resolution)                {
+streamOptions.resolution = this.resolution;
+}
 
             promise = RTCUtils.obtainAudioAndVideoPermissions(streamOptions)
                 .then(function (streamsInfo) {
  */
 JitsiLocalTrack.prototype.isMuted = function () {
     // this.stream will be null when we mute local video on Chrome
-    if (!this.stream)
-        {return true;}
+    if (!this.stream)        {
+return true;
+}
     if (this.isVideoTrack() && !this.isActive()) {
         return true;
     } else {
     // 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)
-        {return this.ssrc.groups[0].ssrcs[0];}
-    else if(this.ssrc && this.ssrc.ssrcs && this.ssrc.ssrcs.length)
-        {return this.ssrc.ssrcs[0];}
-    else
-        {return null;}
+    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)        {
+return this.ssrc.ssrcs[0];
+}    else        {
+return null;
+}
 };
 
 /**
  */
 JitsiLocalTrack.prototype._checkForCameraIssues = function () {
     if(!this.isVideoTrack() || this.stopStreamInProgress ||
-        this.videoType === VideoType.DESKTOP)
-        {return false;}
+        this.videoType === VideoType.DESKTOP)        {
+return false;
+}
 
     return !this._isReceivingData();
 };
  * @returns {boolean} true if the stream is receiving data and false otherwise.
  */
 JitsiLocalTrack.prototype._isReceivingData = function () {
-    if(!this.stream)
-        {return false;}
+    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

     // increase ttfm values
     this.hasBeenMuted = muted;
     // Bind 'onmute' and 'onunmute' event handlers
-    if (this.rtc && this.track)
-        {this._bindMuteHandlers();}
+    if (this.rtc && this.track)        {
+this._bindMuteHandlers();
+}
 }
 
 JitsiRemoteTrack.prototype = Object.create(JitsiTrack.prototype);
  * @param value the muted status.
  */
 JitsiRemoteTrack.prototype.setMute = function (value) {
-    if(this.muted === value)
-        {return;}
+    if(this.muted === value)        {
+return;
+}
 
-    if(value)
-        {this.hasBeenMuted = true;}
+    if(value)        {
+this.hasBeenMuted = true;
+}
 
     // we can have a fake video stream
-    if(this.stream)
-        {this.stream.muted = value;}
+    if(this.stream)        {
+this.stream.muted = value;
+}
 
     this.muted = value;
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, this);
  * @param type the new video type("camera", "desktop")
  */
 JitsiRemoteTrack.prototype._setVideoType = function (type) {
-    if(this.videoType === type)
-        {return;}
+    if(this.videoType === type)        {
+return;
+}
     this.videoType = type;
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
 };
     this.conference.getConnectionTimes()[type + ".ttfm"] = ttfm;
     console.log("(TIME) TTFM " + type + ":\t", ttfm);
     var eventName = type +'.ttfm';
-    if(this.hasBeenMuted)
-        {eventName += '.muted';}
+    if(this.hasBeenMuted)        {
+eventName += '.muted';
+}
     Statistics.analytics.sendEvent(eventName, {value: ttfm});
 };
 
  */
 JitsiRemoteTrack.prototype._attachTTFMTracker = function (container) {
     if((ttfmTrackerAudioAttached && this.isAudioTrack())
-        || (ttfmTrackerVideoAttached && this.isVideoTrack()))
-        {return;}
+        || (ttfmTrackerVideoAttached && this.isVideoTrack()))        {
+return;
+}
 
-    if (this.isAudioTrack())
-        {ttfmTrackerAudioAttached = true;}
-    if (this.isVideoTrack())
-        {ttfmTrackerVideoAttached = true;}
+    if (this.isAudioTrack())        {
+ttfmTrackerAudioAttached = true;
+}
+    if (this.isVideoTrack())        {
+ttfmTrackerVideoAttached = true;
+}
 
     if (RTCBrowserType.isTemasysPluginUsed()) {
         // XXX Don't require Temasys unless it's to be used because it doesn't
 
         // 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)
-        {return;}
+    if(!stream)        {
+return;
+}
 
     var originalStop = stream.stop;
     stream.stop = function () {
  */
 function addMediaStreamInactiveHandler(mediaStream, handler) {
     // Temasys will use onended
-    if(typeof mediaStream.active !== "undefined")
-        {mediaStream.oninactive = handler;}
-    else
-        {mediaStream.onended = handler;}
+    if(typeof mediaStream.active !== "undefined")        {
+mediaStream.oninactive = handler;
+}    else        {
+mediaStream.onended = handler;
+}
 }
 
 /**
  * @param ssrc the SSRC of this track if known
  */
 function JitsiTrack(conference, stream, track, streamInactiveHandler, trackMediaType,
-                    videoType, ssrc)
-{
+                    videoType, ssrc){
     /**
      * Array with the HTML elements that are displaying the streams.
      * @type {Array}
  */
 JitsiTrack.prototype._setHandler = function (type, handler) {
     this.handlers[type] = handler;
-    if(!this.stream)
-        {return;}
+    if(!this.stream)        {
+return;
+}
 
     if(type === "inactive") {
         if (RTCBrowserType.isFirefox()) {
  * @returns {string|null} id of the track or null if this is fake track.
  */
 JitsiTrack.prototype.getId = function () {
-    if(this.stream)
-        {return RTCUtils.getStreamID(this.stream);}
-    else
-        {return null;}
+    if(this.stream)        {
+return RTCUtils.getStreamID(this.stream);
+}    else        {
+return null;
+}
 };
 
 /**
  * @returns {boolean} whether MediaStream is active.
  */
 JitsiTrack.prototype.isActive = function () {
-    if(typeof this.stream.active !== "undefined")
-        {return this.stream.active;}
-    else
-        {return true;}
+    if(typeof this.stream.active !== "undefined")        {
+return this.stream.active;
+}    else        {
+return true;
+}
 };
 
 /**
  * @param handler handler for the event.
  */
 JitsiTrack.prototype.on = function (eventId, handler) {
-    if(this.eventEmitter)
-        {this.eventEmitter.on(eventId, handler);}
+    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)
-        {this.eventEmitter.removeListener(eventId, handler);}
+    if(this.eventEmitter)        {
+this.eventEmitter.removeListener(eventId, handler);
+}
 };
 
 // Common aliases for event emitter

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)
-            {this.dataChannels.sendSelectedEndpointMessage(id);}
+        if(this.dataChannels && this.dataChannelsOpen)            {
+this.dataChannels.sendSelectedEndpointMessage(id);
+}
     }
 
     /**
     }
 
     addLocalTrack (track) {
-        if (!track)
-            {throw new Error('track must not be null nor undefined');}
+        if (!track)            {
+throw new Error('track must not be null nor undefined');
+}
 
         this.localTracks.push(track);
 
         let tracks = this.localTracks.slice();
         if (mediaType !== undefined) {
             tracks = tracks.filter(
-                (track) => { return track.getType() === mediaType; });
+                (track) => {
+ return track.getType() === mediaType; 
+});
         }
         return tracks;
     }
      * @returns {JitsiRemoteTrack|null}
      */
     getRemoteTrackByType (type, resource) {
-        if (this.remoteTracks[resource])
-            {return this.remoteTracks[resource][type];}
-        else
-            {return null;}
+        if (this.remoteTracks[resource])            {
+return this.remoteTracks[resource][type];
+}        else            {
+return null;
+}
     }
 
     /**
     dispose () { }
 
     setAudioLevel (resource, audioLevel) {
-        if(!resource)
-            {return;}
+        if(!resource)            {
+return;
+}
         var audioTrack = this.getRemoteAudioTrack(resource);
         if(audioTrack) {
             audioTrack.setAudioLevel(audioLevel);
      */
     getResourceBySSRC (ssrc) {
         if (this.getLocalTracks().find(
-                localTrack => { return localTrack.getSSRC() == ssrc; })) {
+                localTrack => {
+ return localTrack.getSSRC() == ssrc; 
+})) {
             return this.conference.myUserId();
         }
 

modules/RTC/RTCBrowserType.js

     // Try all browser detectors
     for (var i = 0; i < detectors.length; i++) {
         version = detectors[i]();
-        if (version)
-            {return version;}
+        if (version)            {
+return version;
+}
     }
     logger.warn("Browser type defaults to Safari ver 1");
     currentBrowser = RTCBrowserType.RTC_BROWSER_SAFARI;

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)
-        {constraints.video.mandatory.maxWidth =
-            constraints.video.mandatory.minWidth;}
-    if (constraints.video.mandatory.minHeight)
-        {constraints.video.mandatory.maxHeight =
-            constraints.video.mandatory.minHeight;}
+    if (constraints.video.mandatory.minWidth)        {
+constraints.video.mandatory.maxWidth =
+            constraints.video.mandatory.minWidth;
+}
+    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)
-                            {element.play();}
+                        if (stream)                            {
+element.play();
+}
                     }
                     return element;
                 });
                         return this.audioTracks;
                     };
                 }
-            }
-            // Detect IE/Safari
-            else if (RTCBrowserType.isTemasysPluginUsed()) {
+            } else if (RTCBrowserType.isTemasysPluginUsed()) {
+                // Detect IE/Safari
                 const webRTCReadyCb = () => {
                     this.peerconnection = RTCPeerConnection;
                     this.getUserMedia = window.getUserMedia;
                             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)
-            {throw new Error("WebRTC not ready yet");}
+        if (!rtcReady)            {
+throw new Error("WebRTC not ready yet");
+}
         var isEnumerateDevicesAvailable
             = navigator.mediaDevices && navigator.mediaDevices.enumerateDevices;
         if (isEnumerateDevicesAvailable) {

modules/RTC/ScreenObtainer.js

         this.options = options = options || {};
         gumFunction = gum;
 
-        if (RTCBrowserType.isFirefox())
-            {initFirefoxExtensionDetection(options);}
+        if (RTCBrowserType.isFirefox())            {
+initFirefoxExtensionDetection(options);
+}
 
         if (RTCBrowserType.isNWJS()) {
             obtainDesktopStream = (options, onSuccess, onFailure) => {
         if (firefoxExtInstalled === null) {
             window.setTimeout(
                 () => {
-                    if (firefoxExtInstalled === null)
-                        {firefoxExtInstalled = false;}
+                    if (firefoxExtInstalled === null)                        {
+firefoxExtInstalled = false;
+}
                     this.obtainScreenOnFirefox(callback, errorCallback);
                 },
                 300);
  * @param options supports "desktopSharingChromeExtId"
  * @returns {string}
  */
-function getWebStoreInstallUrl(options)
-{
+function getWebStoreInstallUrl(options){
     return "https://chrome.google.com/webstore/detail/" +
         options.desktopSharingChromeExtId;
 }
             var n1 = 0,
                 n2 = 0;
 
-            if (i < s1.length)
-                {n1 = parseInt(s1[i]);}
-            if (i < s2.length)
-                {n2 = parseInt(s2[i]);}
+            if (i < s1.length)                {
+n1 = parseInt(s1[i]);
+}
+            if (i < s2.length)                {
+n2 = parseInt(s2[i]);
+}
 
             if (isNaN(n1) || isNaN(n2)) {
                 return true;
         // 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;
  * website of published extension.
  * @param options supports "desktopSharingChromeExtId"
  */
-function initInlineInstalls(options)
-{
+function initInlineInstalls(options){
     if($("link[rel=chrome-webstore-item]").length === 0) {
         $("head").append("<link rel=\"chrome-webstore-item\">");
     }
         // 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)
-        {return;}
+    if (firefoxExtInstalled === false || firefoxExtInstalled === true)        {
+return;
+}
     if (!options.desktopSharingFirefoxExtId) {
         firefoxExtInstalled = false;
         return;

modules/RTC/TraceablePeerConnection.js

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

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)
-            {return;}
+        if (!isLocal || !this.audioTrack || this._eventFired)            {
+return;
+}
 
         if (this.audioTrack.isMuted() && audioLevel > 0.6) {
             this._eventFired = true;
      * @private
      */
     _trackAdded(track) {
-        if (this._isLocalAudioTrack(track))
-            {this.audioTrack = track;}
+        if (this._isLocalAudioTrack(track))            {
+this.audioTrack = track;
+}
     }
 
     /**
      * @private
      */
     _trackMuteChanged(track) {
-        if (this._isLocalAudioTrack(track) && track.isMuted())
-            {this._eventFired = false;}
+        if (this._isLocalAudioTrack(track) && track.isMuted())            {
+this._eventFired = false;
+}
     }
 }

modules/connectivity/ConnectionQuality.js

         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

                 var error = report.data;
                 CallStats._reportError.call(this, error.type, error.error,
                     error.pc);
-            }
-            // if we have and event to report and we failed to add fabric
-            // this event will not be reported anyway, returning an error
-            else if (report.type === reportType.EVENT
+            } else if (report.type === reportType.EVENT
                 && fabricInitialized) {
+                // if we have and event to report and we failed to add fabric
+                // this event will not be reported anyway, returning an error
                 var eventData = report.data;
                 callStats.sendFabricEvent(
                     this.peerconnection,
  */
 CallStats._checkInitialize = function () {
     if (CallStats.initialized || !CallStats.initializeFailed
-        || !callStats || CallStats.initializeInProgress)
-        {return;}
+        || !callStats || CallStats.initializeInProgress)        {
+return;
+}
 
     // callstats object created, not initialized and it had previously failed,
     // and there is no init in progress, so lets try initialize it again
 };
 
 CallStats.prototype.pcCallback = _try_catch(function (err, msg) {
-    if (callStats && err !== 'success')
-        {logger.error("Monitoring status: "+ err + " msg: " + msg);}
+    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])
-            {maxVolume = samples[i];}
+        if (maxVolume < samples[i])            {
+maxVolume = samples[i];
+}
     }
 
     return parseFloat(((maxVolume - 127) / 128).toFixed(3));
     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())
-        {return;}
+        RTCBrowserType.isTemasysPluginUsed())        {
+return;
+}
     context.resume();
     var analyser = context.createAnalyser();
     analyser.smoothingTimeConstant = WEBAUDIO_ANALYZER_SMOOTING_TIME;

modules/statistics/RTPStatsCollector.js

  * @returns {number} packet loss percent
  */
 function calculatePacketLoss(lostPackets, totalPackets) {
-    if(!totalPackets || totalPackets <= 0 || !lostPackets || lostPackets <= 0)
-        {return 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)
-        {throw "The browser type '" + this._browserType + "' isn't supported!";}
+    if (!keys)        {
+throw "The browser type '" + this._browserType + "' isn't supported!";
+}
     /**
      * The function which is to be used to retrieve the value associated in a
      * report returned by RTCPeerConnection#getStats with a LibJitsiMeet
                         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)
-            {return key;}
-        else
-            {throw "The property '" + name + "' isn't supported!";}
+        if (key)            {
+return key;
+}        else            {
+throw "The property '" + name + "' isn't supported!";
+}
     };
 
     // Define the function which retrieves the value from a specific report
         // example, if item has a stat property of type function, then it's very
         // likely that whoever defined it wanted you to call it in order to
         // retrieve the value associated with a specific key.
-        itemStatByKey = function (item, key) { return item.stat(key); };
+        itemStatByKey = function (item, key) {
+ return item.stat(key); 
+};
         break;
     case RTCBrowserType.RTC_BROWSER_REACT_NATIVE:
         // The implementation provided by react-native-webrtc follows the
         };
         break;
     default:
-        itemStatByKey = function (item, key) { return item[key]; };
+        itemStatByKey = function (item, key) {
+ return item[key]; 
+};
     }
 
     // Compose the 2 functions defined above to get a function which retrieves
                     "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")
-                {continue;}
+            }            catch(e){/*not supported*/}
+            if(!ip || !type || !localip || active != "true")                {
+continue;
+}
             // Save the address unless it has been saved already.
             var conferenceStatsTransport = this.conferenceStats.transport;
-            if(!conferenceStatsTransport.some(function (t) { return (
+            if(!conferenceStatsTransport.some(function (t) {
+ return (
                         t.ip == ip && t.type == type && t.localip == localip
-                    );})) {
+                    );
+})) {
                 conferenceStatsTransport.push(
                     {ip: ip, type: type, localip: localip});
             }
         }
 
         if(now.type == "candidatepair") {
-            if(now.state == "succeeded")
-                {continue;}
+            if(now.state == "succeeded")                {
+continue;
+}
 
             var local = this.currentStatsReport[now.localCandidateId];
             var remote = this.currentStatsReport[now.remoteCandidateId];
                 continue;
             }
         }
-        if (!packetsNow || packetsNow < 0)
-            {packetsNow = 0;}
+        if (!packetsNow || packetsNow < 0)            {
+packetsNow = 0;
+}
 
         var packetsBefore = getNonNegativeStat(before, key);
         var packetsDiff = Math.max(0, packetsNow - packetsBefore);
                 (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')
-            {continue;}
+        if (now.type != 'ssrc')            {
+continue;
+}
 
         var before = this.baselineAudioLevelsReport[idx];
         var ssrc = getStatValue(now, 'ssrc');
         }
 
         if (!ssrc) {
-            if ((Date.now() - now.timestamp) < 3000)
-                {logger.warn("No ssrc: ");}
+            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)
-        {loadCallStatsAPI(this.options.callStatsCustomScriptUrl);}
+    if(this.callStatsIntegrationEnabled)        {
+loadCallStatsAPI(this.options.callStatsCustomScriptUrl);
+}
     this.callStats = null;
     // Flag indicates whether or not the CallStats have been started for this
     // Statistics instance
 Statistics.localStats = [];
 
 Statistics.startLocalStats = function (stream, callback) {
-    if(!Statistics.audioLevelsEnabled)
-        {return;}
+    if(!Statistics.audioLevelsEnabled)        {
+return;
+}
     var localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
         callback);
     this.localStats.push(localStats);
 };
 
 Statistics.prototype.addAudioLevelListener = function(listener) {
-    if(!Statistics.audioLevelsEnabled)
-        {return;}
+    if(!Statistics.audioLevelsEnabled)        {
+return;
+}
     this.eventEmitter.on(StatisticsEvents.AUDIO_LEVEL, listener);
 };
 
 Statistics.prototype.removeAudioLevelListener = function(listener) {
-    if(!Statistics.audioLevelsEnabled)
-        {return;}
+    if(!Statistics.audioLevelsEnabled)        {
+return;
+}
     this.eventEmitter.removeListener(StatisticsEvents.AUDIO_LEVEL, listener);
 };
 
     }
     this.stopCallStats();
     this.stopRemoteStats();
-    if(this.eventEmitter)
-        {this.eventEmitter.removeAllListeners();}
+    if(this.eventEmitter)        {
+this.eventEmitter.removeAllListeners();
+}
 };
 
 Statistics.stopLocalStats = function (stream) {
-    if(!Statistics.audioLevelsEnabled)
-        {return;}
+    if(!Statistics.audioLevelsEnabled)        {
+return;
+}
 
-    for(var i = 0; i < Statistics.localStats.length; i++)
-        {if(Statistics.localStats[i].stream === stream){
+    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();
             break;
-        }}
+        }
+}
 };
 
 Statistics.prototype.stopRemoteStats = function () {
 Statistics.prototype.stopCallStats = function () {
     if(this.callStatsStarted) {
         var index = Statistics.callsStatsInstances.indexOf(this.callstats);
-        if(index > -1)
-            {Statistics.callsStatsInstances.splice(index, 1);}
+        if(index > -1)            {
+Statistics.callsStatsInstances.splice(index, 1);
+}
         // The next line is commented because we need to be able to send
         // feedback even after the conference has been destroyed.
         // this.callstats = null;
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendIceConnectionFailedEvent = function (pc) {
-    if(this.callstats)
-        {this.callstats.sendIceConnectionFailedEvent(pc, 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)
-        {CallStats.sendMuteEvent(muted, type, this.callstats);}
+    if(this.callstats)        {
+CallStats.sendMuteEvent(muted, type, this.callstats);
+}
 };
 
 /**
  * false for not stopping
  */
 Statistics.prototype.sendScreenSharingEvent = function (start) {
-    if(this.callstats)
-        {CallStats.sendScreenSharingEvent(start, this.callstats);}
+    if(this.callstats)        {
+CallStats.sendScreenSharingEvent(start, this.callstats);
+}
 };
 
 /**
  * conference.
  */
 Statistics.prototype.sendDominantSpeakerEvent = function () {
-    if(this.callstats)
-        {CallStats.sendDominantSpeakerEvent(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)
-        {CallStats.sendCreateOfferFailed(e, pc, 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)
-        {CallStats.sendCreateAnswerFailed(e, pc, 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)
-        {CallStats.sendSetLocalDescFailed(e, pc, 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)
-        {CallStats.sendSetRemoteDescFailed(e, pc, 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)
-        {CallStats.sendAddIceCandidateFailed(e, pc, 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)
-        {this.callstats.sendFeedback(overall, detailed);}
+    if(this.callstats)        {
+this.callstats.sendFeedback(overall, detailed);
+}
     Statistics.analytics.sendEvent("feedback.rating",
         {value: overall, detailed: detailed});
 };

modules/transcription/audioRecorder.js

 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

 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

     console.log("the audio file being sent: " + audioFileBlob);
     var request = new XMLHttpRequest();
     request.onreadystatechange = function() {
-        if(request.readyState === XMLHttpRequest.DONE && request.status === 200)
-        {
+        if(request.readyState === XMLHttpRequest.DONE
+            && request.status === 200) {
             callback(request.responseText);
-        }
-        else if (request.readyState === XMLHttpRequest.DONE) {
+        } else if (request.readyState === XMLHttpRequest.DONE) {
             throw new Error("unable to accept response from sphinx server." +
                 "status: " + request.status);
         }
     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")
-        {throw new Error("Invalid arguments passed to EventEmitterForwarder");}
+        typeof dest.emit !== "function")        {
+throw new Error("Invalid arguments passed to EventEmitterForwarder");
+}
     this.src = src;
     this.dest = dest;
 }

modules/util/GlobalOnErrorHandler.js

     handlers.forEach(function (handler) {
         handler(message, source, lineno, colno, error);
     });
-    if (oldOnErrorHandler)
-        {oldOnErrorHandler(message, source, lineno, colno, error);}
+    if (oldOnErrorHandler)        {
+oldOnErrorHandler(message, source, lineno, colno, error);
+}
 }
 
 // If an old handler exists, also fire its events.
     handlers.forEach(function (handler) {
         handler(null, null, null, null, event.reason);
     });
-    if(oldOnUnhandledRejection)
-        {oldOnUnhandledRejection(event);}
+    if(oldOnUnhandledRejection)        {
+oldOnUnhandledRejection(event);
+}
 }
 
 // Setting the custom error handlers.
      */
     callErrorHandler: function (error) {
         var errHandler = window.onerror;
-        if(!errHandler)
-            {return;}
+        if(!errHandler)            {
+return;
+}
         errHandler(null, null, null, null, error);
     },
     /**
      */
     callUnhandledRejectionHandler: function (error) {
         var errHandler = window.onunhandledrejection;
-        if(!errHandler)
-            {return;}
+        if(!errHandler)            {
+return;
+}
         errHandler(error);
     }
 };

modules/util/ScriptUtil.js

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

modules/version/ComponentsVersions.js

     }.bind(this));
 
     // logs versions to stats
-    if (log.length > 0)
-        {Statistics.sendLog(JSON.stringify(log));}
+    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)
-                {packet.t(node.value);}
-            if(node.children)
-                {this.json2packet(node.children, packet);}
+            if(node.value)                {
+packet.t(node.value);
+}
+            if(node.children)                {
+this.json2packet(node.children, packet);
+}
             packet.up();
         }
         // packet.up();
  */
 function filterNodeFromPresenceJSON(pres, nodeName){
     var res = [];
-    for(let i = 0; i < pres.length; i++)
-        {if(pres[i].tagName === nodeName)
-            {res.push(pres[i]);}}
+    for(let i = 0; i < pres.length; i++)        {
+if(pres[i].tagName === nodeName)            {
+res.push(pres[i]);
+}
+}
 
     return res;
 }
         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)
-                    {this.locked = true;}
+                if (this.password)                    {
+this.locked = true;
+}
 
                 this.eventEmitter.emit(XMPPEvents.MUC_JOINED);
             }
             }
 
             // store the new display name
-            if(member.displayName)
-                {memberOfThis.displayName = 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)
-                        {break;}
+                    if(!att)                        {
+break;
+}
                     this.phoneNumber = att.phone || null;
                     this.phonePin = att.pin || null;
                     this.eventEmitter.emit(XMPPEvents.PHONE_NUMBER_CHANGED);
             this.eventEmitter.emit(XMPPEvents.PRESENCE_STATUS, from, member.status);
         }
 
-        if(jibri)
-        {
+        if(jibri)        {
             this.lastJibri = jibri;
-            if(this.recording)
-                {this.recording.handleJibriPresence(jibri);}
+            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)
-                {this.recording.handleJibriPresence(this.lastJibri);}
+            if(this.lastJibri)                {
+this.recording.handleJibriPresence(this.lastJibri);
+}
         }
         logger.info("Ignore focus: " + from + ", real JID: " + mucJid);
     }
 
         delete this.lastPresences[jid];
 
-        if(skipEvents)
-            {return;}
+        if(skipEvents)            {
+return;
+}
 
         this.eventEmitter.emit(XMPPEvents.MUC_MEMBER_LEFT, jid);
 
         if (!isSelfPresence) {
             delete this.members[from];
             this.onParticipantLeft(from, false);
-        }
-        // If the status code is 110 this means we're leaving and we would like
-        // to remove everyone else from our view, so we trigger the event.
-        else if (Object.keys(this.members).length > 0) {
+        } else if (Object.keys(this.members).length > 0) {
+            // If the status code is 110 this means we're leaving and we would
+            // like to remove everyone else from our view, so we trigger the
+            // event.
             for (const i in this.members) {
                 const member = this.members[i];
                 delete this.members[i];
 
             // we fire muc_left only if this is not a kick,
             // kick has both statuses 110 and 307.
-            if (!isKick)
-                {this.eventEmitter.emit(XMPPEvents.MUC_LEFT);}
+            if (!isKick)                {
+this.eventEmitter.emit(XMPPEvents.MUC_LEFT);
+}
         }
 
         if (isKick && this.myroomjid === from) {
 
     removeFromPresence (key) {
         var nodes = this.presMap.nodes.filter(function(node) {
-            return key !== node.tagName;});
+            return key !== node.tagName;
+});
         this.presMap.nodes = nodes;
     }
 
 
     setVideoMute (mute, callback) {
         this.sendVideoInfoPresence(mute);
-        if(callback)
-            {callback(mute);}
+        if(callback)            {
+callback(mute);
+}
     }
 
     setAudioMute (mute, callback) {
         if(this.connection) {
             this.sendPresence();
         }
-        if(callback)
-            {callback();}
+        if(callback)            {
+callback();
+}
     }
 
     addVideoInfoToPresence (mute) {
 
     sendVideoInfoPresence (mute) {
         this.addVideoInfoToPresence(mute);
-        if(!this.connection)
-            {return;}
+        if(!this.connection)            {
+return;
+}
         this.sendPresence();
     }
 
      * Returns true if the recording is supproted and false if not.
      */
     isRecordingSupported () {
-        if(this.recording)
-            {return this.recording.isSupported();}
+        if(this.recording)            {
+return this.recording.isSupported();
+}
         return false;
     }
 
      * @param statusChangeHandler {function} receives the new status as argument.
      */
     toggleRecording (options, statusChangeHandler) {
-        if(this.recording)
-            {return this.recording.toggleRecording(options, statusChangeHandler);}
+        if(this.recording)            {
+return this.recording.toggleRecording(options, statusChangeHandler);
+}
 
         return statusChangeHandler("error",
             new Error("The conference is not created yet!"));
      * Returns true if the SIP calls are supported and false otherwise
      */
     isSIPCallingSupported () {
-        if(this.moderator)
-            {return this.moderator.isSipGatewayEnabled();}
+        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)
-                            {return;}
+                        if (this.webrtcIceTcpDisable)                            {
+return;
+}
                     } else if (protocol == 'udp') {
-                        if (this.webrtcIceUdpDisable)
-                            {return;}
+                        if (this.webrtcIceUdpDisable)                            {
+return;
+}
                     }
                 }
             }
         // "closed" instead.
         // I suppose at some point this will be moved to onconnectionstatechange
         this.peerconnection.onsignalingstatechange = () => {
-            if (!this.peerconnection) {return;}
+            if (!this.peerconnection) {
+return;
+}
             if (this.peerconnection.signalingState === 'stable') {
                 this.wasstable = true;
             } else if (
          * the value of RTCPeerConnection.iceConnectionState changes.
          */
         this.peerconnection.oniceconnectionstatechange = () => {
-            if (!this.peerconnection) {return;}
+            if (!this.peerconnection) {
+return;
+}
             const now = window.performance.now();
             this.room.connectionTimes["ice.state." +
             this.peerconnection.iceConnectionState] = now;
 
                     break;
                 case 'disconnected':
-                    if (this.closed)
-                        {break;}
+                    if (this.closed)                        {
+break;
+}
                     this.isreconnect = true;
                     // Informs interested parties that the connection has been
                     // interrupted.
-                    if (this.wasstable)
-                        {this.room.eventEmitter.emit(
-                            XMPPEvents.CONNECTION_INTERRUPTED);}
+                    if (this.wasstable)                        {
+this.room.eventEmitter.emit(
+                            XMPPEvents.CONNECTION_INTERRUPTED);
+}
                     break;
                 case 'failed':
                     this.room.eventEmitter.emit(
                 if (this.drip_container.length === 0) {
                     // start 20ms callout
                     setTimeout(() => {
-                        if (this.drip_container.length === 0) {return;}
+                        if (this.drip_container.length === 0) {
+return;
+}
                         this.sendIceCandidates(this.drip_container);
                         this.drip_container = [];
                     }, 20);
                 }
                 $(this).find('>parameter').each(function () {
                     lines += 'a=ssrc:' + ssrc + ' ' + $(this).attr('name');
-                    if ($(this).attr('value') && $(this).attr('value').length)
-                        {lines += ':' + $(this).attr('value');}
+                    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))
-                    {return;}
+                if (!SDPUtil.find_line(media, 'a=mid:' + name))                    {
+return;
+}
                 if (!addSsrcInfo[idx]) {
                     addSsrcInfo[idx] = '';
                 }
                             logger.debug("Renegotiate: setting local description");
                             this.peerconnection.setLocalDescription(
                                 answer,
-                                () => { resolve(); },
+                                () => {
+ resolve(); 
+},
                                 (error) => {
                                     reject(
                                         "setLocalDescription failed: " + error);
                                 }
                             );
                         },
-                        (error) => { reject("createAnswer failed: " + error); },
+                        (error) => {
+ reject("createAnswer failed: " + error); 
+},
                         media_constraints
                     );
                 },
-                (error) => { reject("setRemoteDescription failed: " + error); }
+                (error) => {
+ reject("setRemoteDescription failed: " + error); 
+}
             );
         });
     }
                 ssrcs.push(ssrc);
             });
             currentRemoteSdp.media.forEach(function(media, idx) {
-                if (!SDPUtil.find_line(media, 'a=mid:' + name))
-                    {return;}
+                if (!SDPUtil.find_line(media, 'a=mid:' + name))                    {
+return;
+}
                 if (!removeSsrcInfo[idx]) {
                     removeSsrcInfo[idx] = '';
                 }
             if (errorElSel.length) {
                 error.code = errorElSel.attr('code');
                 const errorReasonSel = $(errResponse).find('error :first');
-                if (errorReasonSel.length)
-                    {error.reason = errorReasonSel[0].tagName;}
+                if (errorReasonSel.length)                    {
+error.reason = errorReasonSel[0].tagName;
+}
             }
 
             if (!errResponse) {
             ssrcs.forEach(function (ssrcObj) {
                 const desc = $(jingle.tree()).find(">jingle>content[name=\"" +
                     ssrcObj.mtype + "\"]>description");
-                if (!desc || !desc.length)
-                    {return;}
+                if (!desc || !desc.length)                    {
+return;
+}
                 ssrcObj.ssrcs.forEach(function (ssrc) {
                     const sourceNode = desc.find(">source[ssrc=\"" +
                         ssrc + "\"]");
     fixSourceRemoveJingle(jingle) {
         let ssrcs = this.modifiedSSRCs["mute"];
         this.modifiedSSRCs["mute"] = [];
-        if (ssrcs && ssrcs.length)
-            {ssrcs.forEach(function (ssrcObj) {
+        if (ssrcs && ssrcs.length)            {
+ssrcs.forEach(function (ssrcObj) {
                 ssrcObj.ssrcs.forEach(function (ssrc) {
                     const sourceNode
                         = $(jingle.tree()).find(">jingle>content[name=\"" +
                             group.ssrcs[0] + "\"])");
                     groupNode.remove();
                 });
-            });}
+            });
+}
 
         ssrcs = this.modifiedSSRCs["remove"];
         this.modifiedSSRCs["remove"] = [];
-        if (ssrcs && ssrcs.length)
-            {ssrcs.forEach(function (ssrcObj) {
+        if (ssrcs && ssrcs.length)            {
+ssrcs.forEach(function (ssrcObj) {
                 const desc
                     = JingleSessionPC.createDescriptionNode(
                         jingle, ssrcObj.mtype);
                             "</ssrc-group>");
                     }
                 });
-            });}
+            });
+}
     }
 
     /**

modules/xmpp/SDP.js

     var medias = this.getMediaSsrcMap();
     var result = false;
     Object.keys(medias).forEach(function (mediaindex) {
-        if (result)
-            {return;}
+        if (result)            {
+return;
+}
         if (medias[mediaindex].ssrcs[ssrc]) {
             result = true;
         }
         lines = this.media[i].split('\r\n');
         lines.pop(); // remove empty last element
         mline = SDPUtil.parse_mline(lines.shift());
-        if (mline.media != 'audio')
-            {continue;}
+        if (mline.media != 'audio')            {
+continue;
+}
         newdesc = '';
         mline.fmt.length = 0;
         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')
-                    {continue;}
+                if (rtpmap.name == 'CN' || rtpmap.name == 'ISAC')                    {
+continue;
+}
                 mline.fmt.push(rtpmap.id);
             }
             newdesc += lines[j] + '\r\n';
                 protocol: sctpAttrs[1] /* protocol */
             });
         // Optional stream count attribute
-        if (sctpAttrs.length > 2)
-            {elem.attrs({ streams: sctpAttrs[2]});}
+        if (sctpAttrs.length > 2)            {
+elem.attrs({ streams: sctpAttrs[2]});
+}
         elem.up();
     }
     // XEP-0320
     }
     if (!sctp.length) {
         tmp.fmt = desc.find('payload-type').map(
-            function () { return this.getAttribute('id'); }).get();
+            function () {
+ return this.getAttribute('id');
+}).get();
         media += SDPUtil.build_mline(tmp) + '\r\n';
     } else {
         media += 'm=application 1 DTLS/SCTP ' + sctp.attr('number') + '\r\n';
             ' ' + sctp.attr('protocol');
 
         var streamCount = sctp.attr('streams');
-        if (streamCount)
-            {media += ' ' + streamCount + '\r\n';}
-        else
-            {media += '\r\n';}
+        if (streamCount)            {
+media += ' ' + streamCount + '\r\n';
+}        else            {
+media += '\r\n';
+}
     }
 
     media += 'c=IN IP4 0.0.0.0\r\n';
-    if (!sctp.length)
-        {media += 'a=rtcp:1 IN IP4 0.0.0.0\r\n';}
+    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"]');
     if (tmp.length) {
         if (tmp.attr('ufrag')) {
             var value = this.getAttribute('value');
             value = SDPUtil.filter_special_chars(value);
             media += 'a=ssrc:' + ssrc + ' ' + name;
-            if (value && value.length)
-                {media += ':' + value;}
+            if (value && value.length)                {
+media += ':' + value;
+}
             media += '\r\n';
         });
     });

modules/xmpp/SDPDiffer.js

 var SDPUtil = require("./SDPUtil");
 
-function SDPDiffer(mySDP, otherSDP)
-{
+function SDPDiffer(mySDP, otherSDP){
     this.mySDP = mySDP;
     this.otherSDP = otherSDP;
 }
     // this could be useful in Array.prototype.
     function arrayEquals(array) {
         // if the other array is a falsy value, return
-        if (!array)
-            {return false;}
+        if (!array)            {
+return false;
+}
 
         // compare lengths - can save a lot of time
-        if (this.length != array.length)
-            {return false;}
+        if (this.length != array.length)            {
+return false;
+}
 
         for (var i = 0, l=this.length; i < l; i++) {
             // 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]))
-                    {return false;}
-            }
-            else if (this[i] != array[i]) {
+                if (!this[i].equals(array[i]))                    {
+return false;
+}
+            }            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)
-                {needles.push(lines[i]);}
+            if (lines[i].substring(0, needle.length) == needle)                {
+needles.push(lines[i]);
+}
         }
         if (needles.length || !sessionpart) {
             return needles;
             logger.log(line);
             return null;
         }
-        if (line.substring(line.length - 2) == '\r\n') // chomp it
-            {line = line.substring(0, line.length - 2);}
+        if (line.substring(line.length - 2) == '\r\n') {// chomp it
+            line = line.substring(0, line.length - 2);
+        }
         var candidate = {},
             elems = line.split(' '),
             i;

modules/xmpp/SdpTransformUtil.js

      */
     containsSSRC(ssrcNumber) {
         return !!this._ssrcs.find(
-            ssrcObj => { return ssrcObj.id == ssrcNumber; });
+            ssrcObj => {
+ return ssrcObj.id == ssrcNumber; 
+});
     }
 
     /**

modules/xmpp/recording.js

 
 Recording.prototype.handleJibriPresence = function (jibri) {
     var attributes = jibri.attributes;
-    if(!attributes)
-        {return;}
+    if(!attributes)        {
+return;
+}
 
     var newState = attributes.status;
     logger.log("Handle jibri presence : ", newState);
 
-    if (newState === this.state)
-        {return;}
+    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.AVAILABLE;}
-        else
-            {this.state = Recording.status.OFF;}
-    }
-    else {
+            || this.state === Recording.status.UNAVAILABLE)            {
+this.state = Recording.status.AVAILABLE;
+}        else            {
+this.state = Recording.status.OFF;
+}
+    }    else {
         this.state = newState;
     }
 
 
     // If the recorder is currently unavailable we throw an error.
     if (oldState === Recording.status.UNAVAILABLE
-        || oldState === Recording.status.FAILED)
-        {statusChangeHandler(Recording.status.FAILED,
-                            JitsiRecorderErrors.RECORDER_UNAVAILABLE);}
-    else if (oldState === Recording.status.BUSY)
-        {statusChangeHandler(Recording.status.BUSY,
-                            JitsiRecorderErrors.RECORDER_BUSY);}
+        || oldState === Recording.status.FAILED)        {
+statusChangeHandler(Recording.status.FAILED,
+                            JitsiRecorderErrors.RECORDER_UNAVAILABLE);
+}    else if (oldState === Recording.status.BUSY)        {
+statusChangeHandler(Recording.status.BUSY,
+                            JitsiRecorderErrors.RECORDER_BUSY);
+}
 
     // If we're about to turn ON the recording we need either a streamId or
     // an authentication token depending on the recording type. If we don't

modules/xmpp/strophe.emuc.js

         }
 
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
-        if(!room)
-            {return;}
+        if(!room)            {
+return;
+}
 
         // Parse status.
         if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]' +
     onPresenceUnavailable (pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
-        if(!room)
-            {return;}
+        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;}
+        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;}
+        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;}
+        if(!room)            {
+return;
+}
 
         room.onMute(iq);
         return true;

modules/xmpp/xmpp.js

         }
     }
 
-    getConnection () { return this.connection; }
+    getConnection () {
+ return this.connection; 
+}
 
     /**
      * Receive connection status changes and handles them.
             this.connection.ping.hasPingSupport(
                 pingJid,
                 function (hasPing) {
-                    if (hasPing)
-                        {this.connection.ping.startInterval(pingJid);}
-                    else
-                        {logger.warn("Ping NOT supported by " + pingJid);}
+                    if (hasPing)                        {
+this.connection.ping.startInterval(pingJid);
+}                    else                        {
+logger.warn("Ping NOT supported by " + pingJid);
+}
                 }.bind(this));
 
-            if (password)
-                {this.authenticatedUser = true;}
+            if (password)                {
+this.authenticatedUser = true;
+}
             if (this.connection && this.connection.connected &&
                 Strophe.getResourceFromJid(this.connection.jid)) {
                 // .connected is true while connecting?