[eslint] max-len

.eslintrc.js

                 'beforeLineComment': true
             }
         ],
+        'max-len': [ 'error', 80 ],
         'max-lines': 0,
         'max-nested-callbacks': 2,
         'max-statements': 0,

JitsiConference.js

  * Creates a JitsiConference object with the given name and properties.
  * Note: this constructor is not a part of the public API (objects should be
  * created using JitsiConnection.createConference).
- * @param options.config properties / settings related to the conference that will be created.
+ * @param options.config properties / settings related to the conference that
+ * will be created.
  * @param options.name the name of the conference
- * @param options.connection the JitsiConnection object for this JitsiConference.
+ * @param options.connection the JitsiConnection object for this
+ * JitsiConference.
  * @constructor
  */
 function JitsiConference(options) {
             callStatsID: this.options.config.callStatsID,
             callStatsSecret: this.options.config.callStatsSecret,
             callStatsConfIDNamespace:
-                this.options.config.callStatsConfIDNamespace || window.location.hostname,
+                this.options.config.callStatsConfIDNamespace
+                    || window.location.hostname,
             callStatsCustomScriptUrl:
                 this.options.config.callStatsCustomScriptUrl,
             roomName: this.options.name
 };
 
 /**
- * Attaches a handler for events(For example - "participant joined".) in the conference. All possible event are defined
- * in JitsiConferenceEvents.
+ * Attaches a handler for events(For example - "participant joined".) in the
+ * conference. All possible event are defined in JitsiConferenceEvents.
  * @param eventId the event ID.
  * @param handler handler for the event.
  *
- * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
+ * Note: consider adding eventing functionality by extending an EventEmitter
+ * impl, instead of rolling ourselves
  */
 JitsiConference.prototype.on = function(eventId, handler) {
     if (this.eventEmitter) {
  * @param eventId the event ID.
  * @param [handler] optional, the specific handler to unbind
  *
- * Note: consider adding eventing functionality by extending an EventEmitter impl, instead of rolling ourselves
+ * Note: consider adding eventing functionality by extending an EventEmitter
+ * impl, instead of rolling ourselves
  */
 JitsiConference.prototype.off = function(eventId, handler) {
     if (this.eventEmitter) {
                 new JitsiTrackError(JitsiTrackErrors.TRACK_IS_DISPOSED));
         }
 
-        // Set up the ssrcHandler for the new track before we add it at the lower levels
+        // Set up the ssrcHandler for the new track before we add it at the
+        // lower levels
         newTrack.ssrcHandler = function(conference, ssrcMap) {
             const trackSSRCInfo = ssrcMap.get(this.getMSID());
 
                 this.onLocalTrackRemoved(oldTrack);
             }
             if (newTrack) {
-                // Now handle the addition of the newTrack at the JitsiConference level
+                // Now handle the addition of the newTrack at the
+                // JitsiConference level
                 this._setupNewTrack(newTrack);
             }
 
 /**
  * Adds loca WebRTC stream to the conference.
  * @param {MediaStream} stream new stream that will be added.
- * @param {function} callback callback executed after successful stream addition.
- * @param {function(error)} errorCallback callback executed if stream addition fail.
- * @param {object} ssrcInfo object with information about the SSRCs associated with the
- * stream.
+ * @param {function} callback callback executed after successful stream
+ * addition.
+ * @param {function(error)} errorCallback callback executed if stream addition
+ * fail.
+ * @param {object} ssrcInfo object with information about the SSRCs associated
+ * with the stream.
  * @param {boolean} [dontModifySources] if <tt>true</tt> _modifySources won't be
  * called. The option is used for adding stream, before the Jingle call is
  * started. That is before the 'session-accept' is sent.
             this.jingleSession.removeStream(
             stream, callback, errorCallback, ssrcInfo);
         } else {
-        // We are done immediately
-            logger.warn('Remove local MediaStream - no JingleSession started yet');
+            // We are done immediately
+            logger.warn(
+                'Remove local MediaStream - no JingleSession started yet');
             callback();
         }
     };
 
         participant._role = role;
         this.participants[id] = participant;
-        this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, id, participant);
+        this.eventEmitter.emit(
+            JitsiConferenceEvents.USER_JOINED,
+            id,
+            participant);
         this.xmpp.caps.getFeatures(jid).then(features => {
             participant._supportsDTMF = features.has('urn:xmpp:jingle:dtmf:0');
             this.updateDTMFSupport();
     }
 
     participant._displayName = displayName;
-    this.eventEmitter.emit(JitsiConferenceEvents.DISPLAY_NAME_CHANGED, id, displayName);
+    this.eventEmitter.emit(
+        JitsiConferenceEvents.DISPLAY_NAME_CHANGED,
+        id,
+        displayName);
 };
 
 /**
          *  consistent
          */
 
-        if (localTrack.isVideoTrack() && localTrack.isMuted() && !RTCBrowserType.isFirefox()) {
+        if (localTrack.isVideoTrack()
+                && localTrack.isMuted()
+                && !RTCBrowserType.isFirefox()) {
             /**
              * Handles issues when the stream is added before the peerconnection
              * is created. The peerconnection is created when second participant
     }
     if (somebodySupportsDTMF !== this.somebodySupportsDTMF) {
         this.somebodySupportsDTMF = somebodySupportsDTMF;
-        this.eventEmitter.emit(JitsiConferenceEvents.DTMF_SUPPORT_CHANGED, somebodySupportsDTMF);
+        this.eventEmitter.emit(
+            JitsiConferenceEvents.DTMF_SUPPORT_CHANGED,
+            somebodySupportsDTMF);
     }
 };
 
  * @return {string} local user's ID
  */
 JitsiConference.prototype.myUserId = function() {
-    return this.room && this.room.myroomjid ? Strophe.getResourceFromJid(this.room.myroomjid) : null;
+    return (
+        this.room
+            && this.room.myroomjid
+                ? Strophe.getResourceFromJid(this.room.myroomjid)
+                : null);
 };
 
 JitsiConference.prototype.sendTones = function(tones, duration, pause) {

JitsiConnection.js

 const Statistics = require('./modules/statistics/statistics');
 
 /**
- * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
- * JitsiConference interface.
- * @param appID identification for the provider of Jitsi Meet video conferencing services.
+ * Creates new connection object for the Jitsi Meet server side video
+ * conferencing service. Provides access to the JitsiConference interface.
+ * @param appID identification for the provider of Jitsi Meet video conferencing
+ * services.
  * @param token the JWT token used to authenticate with the server(optional)
- * @param options Object with properties / settings related to connection with the server.
+ * @param options Object with properties / settings related to connection with
+ * the server.
  * @constructor
  */
 function JitsiConnection(appID, token, options) {

JitsiMeetJS.js

 /* global __filename */
 
 import AuthUtil from './modules/util/AuthUtil';
-import * as ConnectionQualityEvents from './service/connectivity/ConnectionQualityEvents';
+import * as ConnectionQualityEvents
+    from './service/connectivity/ConnectionQualityEvents';
 import GlobalOnErrorHandler from './modules/util/GlobalOnErrorHandler';
 import * as JitsiConferenceErrors from './JitsiConferenceErrors';
 import * as JitsiConferenceEvents from './JitsiConferenceEvents';
 
     /**
      * Creates the media tracks and returns them trough the callback.
-     * @param options Object with properties / settings specifying the tracks which should be created.
-     * should be created or some additional configurations about resolution for example.
+     * @param options Object with properties / settings specifying the tracks
+     * which should be created. should be created or some additional
+     * configurations about resolution for example.
      * @param {Array} options.devices the devices that will be requested
      * @param {string} options.resolution resolution constraints
-     * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with the following structure {stream: the Media Stream,
-     * type: "audio" or "video", videoType: "camera" or "desktop"}
-     * will be returned trough the Promise, otherwise JitsiTrack objects will be returned.
+     * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with
+     * the following structure {stream: the Media Stream, type: "audio" or
+     * "video", videoType: "camera" or "desktop"} will be returned trough the
+     * Promise, otherwise JitsiTrack objects will be returned.
      * @param {string} options.cameraDeviceId
      * @param {string} options.micDeviceId
      * @param {object} options.desktopSharingExtensionExternalInstallation -

doc/example/example.js

         muc: 'conference.jitsi-meet.example.com' // FIXME: use XEP-0030
     },
     bosh: '//jitsi-meet.example.com/http-bind', // FIXME: use xep-0156 for that
-    clientNode: 'http://jitsi.org/jitsimeet' // The name of client node advertised in XEP-0115 'c' stanza
+
+    // The name of client node advertised in XEP-0115 'c' stanza
+    clientNode: 'http://jitsi.org/jitsimeet'
 };
 
 const confOptions = {
             $('body').append(`<video autoplay='1' id='localVideo${i}' />`);
             localTracks[i].attach($(`#localVideo${i}`)[0]);
         } else {
-            $('body').append(`<audio autoplay='1' muted='true' id='localAudio${i}' />`);
+            $('body').append(
+                `<audio autoplay='1' muted='true' id='localAudio${i}' />`);
             localTracks[i].attach($(`#localAudio${i}`)[0]);
         }
         if (isJoined) {
     const id = participant + track.getType() + idx;
 
     if (track.getType() == 'video') {
-        $('body').append(`<video autoplay='1' id='${participant}video${idx}' />`);
+        $('body').append(
+            `<video autoplay='1' id='${participant}video${idx}' />`);
     } else {
-        $('body').append(`<audio autoplay='1' id='${participant}audio${idx}' />`);
+        $('body').append(
+            `<audio autoplay='1' id='${participant}audio${idx}' />`);
     }
     track.attach($(`#${id}`)[0]);
 }
     room.on(JitsiMeetJS.events.conference.TRACK_REMOVED, track => {
         console.log(`track removed!!!${track}`);
     });
-    room.on(JitsiMeetJS.events.conference.CONFERENCE_JOINED, onConferenceJoined);
+    room.on(
+        JitsiMeetJS.events.conference.CONFERENCE_JOINED,
+        onConferenceJoined);
     room.on(JitsiMeetJS.events.conference.USER_JOINED, id => {
         console.log('user join');
         remoteTracks[id] = [];
     room.on(JitsiMeetJS.events.conference.TRACK_MUTE_CHANGED, track => {
         console.log(`${track.getType()} - ${track.isMuted()}`);
     });
-    room.on(JitsiMeetJS.events.conference.DISPLAY_NAME_CHANGED, (userID, displayName) => {
-        console.log(`${userID} - ${displayName}`);
-    });
+    room.on(
+        JitsiMeetJS.events.conference.DISPLAY_NAME_CHANGED,
+        (userID, displayName) => console.log(`${userID} - ${displayName}`));
     room.on(JitsiMeetJS.events.conference.TRACK_AUDIO_LEVEL_CHANGED,
       (userID, audioLevel) => {
           console.log(`${userID} - ${audioLevel}`);
  */
 function disconnect() {
     console.log('disconnect!');
-    connection.removeEventListener(JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED, onConnectionSuccess);
-    connection.removeEventListener(JitsiMeetJS.events.connection.CONNECTION_FAILED, onConnectionFailed);
-    connection.removeEventListener(JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED, disconnect);
+    connection.removeEventListener(
+        JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED,
+        onConnectionSuccess);
+    connection.removeEventListener(
+        JitsiMeetJS.events.connection.CONNECTION_FAILED,
+        onConnectionFailed);
+    connection.removeEventListener(
+        JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED,
+        disconnect);
 }
 
 function unload() {
         localTracks[1].dispose();
         localTracks.pop();
     }
-    JitsiMeetJS.createLocalTracks({ devices: isVideo ? [ 'video' ] : [ 'desktop' ] })
+    JitsiMeetJS.createLocalTracks(
+            { devices: isVideo ? [ 'video' ] : [ 'desktop' ] })
         .then(tracks => {
             localTracks.push(tracks[0]);
-            localTracks[1].addEventListener(JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
-                () => {
-                    console.log('local track muted');
-                });
-            localTracks[1].addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
-                () => {
-                    console.log('local track stoped');
-                });
+            localTracks[1].addEventListener(
+                JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
+                () => console.log('local track muted'));
+            localTracks[1].addEventListener(
+                JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
+                () => console.log('local track stoped'));
             localTracks[1].attach($('#localVideo1')[0]);
             room.addTrack(localTracks[1]);
         })
 
 if (JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
     JitsiMeetJS.mediaDevices.enumerateDevices(devices => {
-        const audioOutputDevices = devices.filter(d => d.kind === 'audiooutput');
+        const audioOutputDevices
+            = devices.filter(d => d.kind === 'audiooutput');
 
         if (audioOutputDevices.length > 1) {
             $('#audioOutputSelect').html(
-                audioOutputDevices.map(d => `<option value="${d.deviceId}">${d.label}</option>`).join('\n')
-            );
+                audioOutputDevices
+                    .map(
+                        d =>
+                            `<option value="${d.deviceId}">${d.label}</option>`)
+                    .join('\n'));
 
             $('#audioOutputSelectWrapper').show();
         }

modules/RTC/DataChannels.js

     this._dataChannels = [];
 
     // Sample code for opening new data channel from Jitsi Meet to the bridge.
-    // Although it's not a requirement to open separate channels from both bridge
-    // and peer as single channel can be used for sending and receiving data.
-    // So either channel opened by the bridge or the one opened here is enough
-    // for communication with the bridge.
+    // Although it's not a requirement to open separate channels from both
+    // bridge and peer as single channel can be used for sending and receiving
+    // data. So either channel opened by the bridge or the one opened here is
+    // enough for communication with the bridge.
     /* var dataChannelOptions =
      {
      reliable: true
                 self.eventEmitter.emit(
                     RTCEvents.ENDPOINT_MESSAGE_RECEIVED, obj.from,
                     obj.msgPayload);
-            } else if (colibriClass === 'EndpointConnectivityStatusChangeEvent') {
+            } else if (colibriClass
+                    === 'EndpointConnectivityStatusChangeEvent') {
                 const endpoint = obj.endpoint;
                 const isActive = obj.active === 'true';
 

modules/RTC/JitsiLocalTrack.js

         promise = RTCUtils.obtainAudioAndVideoPermissions(streamOptions)
             .then(streamsInfo => {
                 const mediaType = self.getType();
-                const streamInfo = streamsInfo.find(info => info.mediaType === mediaType);
+                const streamInfo
+                    = streamsInfo.find(info => info.mediaType === mediaType);
 
                 if (streamInfo) {
                     self._setStream(streamInfo.stream);
                         JitsiTrackErrors.TRACK_NO_STREAM_FOUND);
                 }
 
-                self.containers = self.containers.map(cont => RTCUtils.attachMediaStream(cont, self.stream));
+                self.containers
+                    = self.containers.map(
+                        cont => RTCUtils.attachMediaStream(cont, self.stream));
 
                 return self._addStreamToConferenceAsUnmute();
             });

modules/RTC/JitsiTrack.js

  * @param videoType the VideoType for this track if any
  * @param ssrc the SSRC of this track if known
  */
-function JitsiTrack(conference, stream, track, streamInactiveHandler, trackMediaType,
-                    videoType, ssrc) {
+function JitsiTrack(
+        conference,
+        stream,
+        track,
+        streamInactiveHandler,
+        trackMediaType,
+        videoType,
+        ssrc) {
     /**
      * Array with the HTML elements that are displaying the streams.
      * @type {Array}
         return Promise.resolve();
     }
 
-    return Promise.all(this.containers.map(element => element.setSinkId(audioOutputDeviceId)
-            .catch(error => {
-                logger.warn(
-                    'Failed to change audio output device on element. Default'
-                    + ' or previously set audio output device will be used.',
-                    element, error);
-                throw error;
-            })))
-    .then(() => {
-        self.eventEmitter.emit(JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED,
-            audioOutputDeviceId);
-    });
+    return (
+        Promise.all(
+                this.containers.map(
+                    element =>
+                        element.setSinkId(audioOutputDeviceId)
+                            .catch(error => {
+                                logger.warn(
+                                    'Failed to change audio output device on'
+                                        + ' element. Default or previously set'
+                                        + ' audio output device will be used.',
+                                    element,
+                                    error);
+                                throw error;
+                            })))
+            .then(() => {
+                self.eventEmitter.emit(
+                    JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED,
+                    audioOutputDeviceId);
+            }));
 };
 
 module.exports = JitsiTrack;

modules/RTC/RTC.js

 
         // A flag whether we had received that the data channel had opened
         // we can get this flag out of sync if for some reason data channel got
-        // closed from server, a desired behaviour so we can see errors when this
-        // happen
+        // closed from server, a desired behaviour so we can see errors when
+        // this happen
         this.dataChannelsOpen = false;
 
-        // Switch audio output device on all remote audio tracks. Local audio tracks
-        // handle this event by themselves.
+        // Switch audio output device on all remote audio tracks. Local audio
+        // tracks handle this event by themselves.
         if (RTCUtils.isDeviceChangeAvailable('output')) {
             RTCUtils.addListener(RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
                 deviceId => {
      * @param {Object} [options] optional parameters
      * @param {Array} options.devices the devices that will be requested
      * @param {string} options.resolution resolution constraints
-     * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with the
-     * following structure {stream: the Media Stream,
-     * type: "audio" or "video", videoType: "camera" or "desktop"}
-     * will be returned trough the Promise, otherwise JitsiTrack objects will be
-     * returned.
+     * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with
+     * the following structure {stream: the Media Stream, type: "audio" or
+     * "video", videoType: "camera" or "desktop"} will be returned trough the
+     * Promise, otherwise JitsiTrack objects will be returned.
      * @param {string} options.cameraDeviceId
      * @param {string} options.micDeviceId
      * @returns {*} Promise object that will receive the new JitsiTracks
      * order to always receive video for this participant (even when last n is
      * enabled).
      * @param id {string} the user id
-     * @throws NetworkError or InvalidStateError or Error if the operation fails.
+     * @throws NetworkError or InvalidStateError or Error if the operation
+     * fails.
      */
     pinEndpoint(id) {
         if (this.dataChannels) {
     }
 
     /**
-     * Gets JitsiRemoteTrack for AUDIO MediaType associated with given MUC nickname
-     * (resource part of the JID).
+     * Gets JitsiRemoteTrack for AUDIO MediaType associated with given MUC
+     * nickname (resource part of the JID).
      * @param resource the resource part of the MUC JID
      * @returns {JitsiRemoteTrack|null}
      */
     }
 
     /**
-     * Gets JitsiRemoteTrack for VIDEO MediaType associated with given MUC nickname
-     * (resource part of the JID).
+     * Gets JitsiRemoteTrack for VIDEO MediaType associated with given MUC
+     * nickname (resource part of the JID).
      * @param resource the resource part of the MUC JID
      * @returns {JitsiRemoteTrack|null}
      */
      * matches given SSRC or <tt>undefined</tt> if no such track was found.
      */
     getRemoteTrackBySSRC(ssrc) {
-        return this.getRemoteTracks().find(remoteTrack => ssrc == remoteTrack.getSSRC());
+        return this.getRemoteTracks().find(t => ssrc == t.getSSRC());
     }
 
     /**

modules/RTC/RTCBrowserType.js

      */
     isTemasysPluginUsed() {
         // Temasys do not support Microsoft Edge:
-        // http://support.temasys.com.sg/support/solutions/articles/5000654345-can-the-temasys-webrtc-plugin-be-used-with-microsoft-edge-
+        // http://support.temasys.com.sg/support/solutions/articles/
+        // 5000654345-can-the-temasys-webrtc-plugin-be-used-with-microsoft-edge-
         if (RTCBrowserType.isIExplorer()
                 && RTCBrowserType.getIExplorerVersion() < 12) {
             return true;

modules/RTC/RTCUtils.js

             // for some cameras it might be necessary to request 30fps
             // so they choose 30fps mjpg over 10fps yuy2
             if (options.minFps || options.fps) {
-                options.minFps = options.minFps || options.fps; // Fall back to options.fps for backwards compatibility
+                // Fall back to options.fps for backwards compatibility
+                options.minFps = options.minFps || options.fps;
                 constraints.video.mandatory.minFrameRate = options.minFps;
             }
             if (options.maxFps) {
         constraints.video.optional.push({ bandwidth: options.bandwidth });
     }
 
-    // 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
+    // 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) {
         // seems to be fixed now, removing this experimental fix, as having
         // multiple audio tracks brake the tests
  */
 function onMediaDevicesListChanged(devicesReceived) {
     currentlyAvailableMediaDevices = devicesReceived.slice(0);
-    logger.info('list of media devices has changed:', currentlyAvailableMediaDevices);
+    logger.info(
+        'list of media devices has changed:',
+        currentlyAvailableMediaDevices);
 
     const videoInputDevices
         = currentlyAvailableMediaDevices.filter(d => d.kind === 'videoinput');
         = audioInputDevices.filter(d => d.label === '');
 
     if (videoInputDevices.length
-        && videoInputDevices.length === videoInputDevicesWithEmptyLabels.length) {
+            && videoInputDevices.length
+                === videoInputDevicesWithEmptyLabels.length) {
         devices.video = false;
     }
 
     if (audioInputDevices.length
-        && audioInputDevices.length === audioInputDevicesWithEmptyLabels.length) {
+            && audioInputDevices.length
+                === audioInputDevicesWithEmptyLabels.length) {
         devices.audio = false;
     }
 
                 && audioOutputChanged) {
             element.setSinkId(rtcUtils.getAudioOutputDevice())
                 .catch(function(ex) {
-                    const err = new JitsiTrackError(ex, null, [ 'audiooutput' ]);
+                    const err
+                        = new JitsiTrackError(ex, null, [ 'audiooutput' ]);
 
                     GlobalOnErrorHandler.callUnhandledRejectionHandler(
                         { promise: this,
                     return;
                 }
                 this.peerconnection = mozRTCPeerConnection;
-                this.getUserMedia = wrapGetUserMedia(navigator.mozGetUserMedia.bind(navigator));
-                this.enumerateDevices = wrapEnumerateDevices(
-                    navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices)
-                );
+                this.getUserMedia
+                    = wrapGetUserMedia(
+                        navigator.mozGetUserMedia.bind(navigator));
+                this.enumerateDevices
+                    = wrapEnumerateDevices(
+                        navigator.mediaDevices.enumerateDevices.bind(
+                            navigator.mediaDevices));
                 this.pc_constraints = {};
-                this.attachMediaStream = wrapAttachMediaStream((element, stream) => {
-                    //  srcObject is being standardized and FF will eventually
-                    //  support that unprefixed. FF also supports the
-                    //  "element.src = URL.createObjectURL(...)" combo, but that
-                    //  will be deprecated in favour of srcObject.
-                    //
-                    // https://groups.google.com/forum/#!topic/mozilla.dev.media/pKOiioXonJg
-                    // https://github.com/webrtc/samples/issues/302
-                    if (element) {
-                        defaultSetVideoSrc(element, stream);
-                        if (stream) {
-                            element.play();
+                this.attachMediaStream
+                    = wrapAttachMediaStream((element, stream) => {
+                        // srcObject is being standardized and FF will
+                        // eventually support that unprefixed. FF also supports
+                        // the "element.src = URL.createObjectURL(...)" combo,
+                        // but that will be deprecated in favour of srcObject.
+                        //
+                        // https://groups.google.com/forum/#!topic/
+                        // mozilla.dev.media/pKOiioXonJg
+                        // https://github.com/webrtc/samples/issues/302
+                        if (element) {
+                            defaultSetVideoSrc(element, stream);
+                            if (stream) {
+                                element.play();
+                            }
                         }
-                    }
 
-                    return element;
-                });
+                        return element;
+                    });
                 this.getStreamID = function(stream) {
                     let id = stream.id;
 
 
                     return SDPUtil.filter_special_chars(id);
                 };
-                RTCSessionDescription = mozRTCSessionDescription; // eslint-disable-line
-                RTCIceCandidate = mozRTCIceCandidate;             // eslint-disable-line
+
+                /* eslint-disable no-global-assign, no-native-reassign */
+
+                RTCSessionDescription = mozRTCSessionDescription;
+                RTCIceCandidate = mozRTCIceCandidate;
+
+                /* eslint-enable no-global-assign, no-native-reassign */
             } else if (RTCBrowserType.isChrome()
                     || RTCBrowserType.isOpera()
                     || RTCBrowserType.isNWJS()
                     || RTCBrowserType.isReactNative()) {
 
                 this.peerconnection = webkitRTCPeerConnection;
-                const getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
+                const getUserMedia
+                    = navigator.webkitGetUserMedia.bind(navigator);
 
                 if (navigator.mediaDevices) {
                     this.getUserMedia = wrapGetUserMedia(getUserMedia);
-                    this.enumerateDevices = wrapEnumerateDevices(
-                        navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices)
-                    );
+                    this.enumerateDevices
+                        = wrapEnumerateDevices(
+                            navigator.mediaDevices.enumerateDevices.bind(
+                                navigator.mediaDevices));
                 } else {
                     this.getUserMedia = getUserMedia;
-                    this.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
+                    this.enumerateDevices
+                      = enumerateDevicesThroughMediaStreamTrack;
                 }
-                this.attachMediaStream = wrapAttachMediaStream((element, stream) => {
-                    defaultSetVideoSrc(element, stream);
+                this.attachMediaStream
+                    = wrapAttachMediaStream((element, stream) => {
+                        defaultSetVideoSrc(element, stream);
 
-                    return element;
-                });
+                        return element;
+                    });
                 this.getStreamID = function(stream) {
                     // A. MediaStreams from FF endpoints have the characters '{'
                     // and '}' that make jQuery choke.
                 const webRTCReadyCb = () => {
                     this.peerconnection = RTCPeerConnection;
                     this.getUserMedia = window.getUserMedia;
-                    this.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
-                    this.attachMediaStream = wrapAttachMediaStream((element, stream) => {
-                        if (stream) {
-                            if (stream.id === 'dummyAudio'
-                                    || stream.id === 'dummyVideo') {
-                                return;
-                            }
+                    this.enumerateDevices
+                        = enumerateDevicesThroughMediaStreamTrack;
+                    this.attachMediaStream
+                        = wrapAttachMediaStream((element, stream) => {
+                            if (stream) {
+                                if (stream.id === 'dummyAudio'
+                                        || stream.id === 'dummyVideo') {
+                                    return;
+                                }
 
-                            // The container must be visible in order to play or
-                            // attach the stream when Temasys plugin is in use
-                            const containerSel = $(element);
+                                // The container must be visible in order to
+                                // play or attach the stream when Temasys plugin
+                                // is in use
+                                const containerSel = $(element);
 
-                            if (RTCBrowserType.isTemasysPluginUsed()
-                                    && !containerSel.is(':visible')) {
-                                containerSel.show();
-                            }
-                            const video = stream.getVideoTracks().length > 0;
+                                if (RTCBrowserType.isTemasysPluginUsed()
+                                        && !containerSel.is(':visible')) {
+                                    containerSel.show();
+                                }
+                                const video
+                                    = stream.getVideoTracks().length > 0;
 
-                            if (video && !$(element).is(':visible')) {
-                                throw new Error(
-                                    'video element must be visible to attach'
-                                        + ' video stream');
+                                if (video && !$(element).is(':visible')) {
+                                    throw new Error(
+                                        'video element must be visible to'
+                                            + ' attach video stream');
+                                }
                             }
-                        }
 
-                        return attachMediaStream(element, stream);
-                    });
+                            return attachMediaStream(element, stream);
+                        });
                     this.getStreamID
                         = stream => SDPUtil.filter_special_chars(stream.label);
 
     * @param {string} options.cameraDeviceId
     * @param {string} options.micDeviceId
     **/
-    getUserMediaWithConstraints(um, success_callback, failure_callback, options) {
+    getUserMediaWithConstraints(
+            um,
+            success_callback,
+            failure_callback,
+            options) {
         options = options || {};
         const constraints = getConstraints(um, options);
 
      * @param {Object} [options] optional parameters
      * @param {Array} options.devices the devices that will be requested
      * @param {string} options.resolution resolution constraints
-     * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with the following structure {stream: the Media Stream,
-     * type: "audio" or "video", videoType: "camera" or "desktop"}
-     * will be returned trough the Promise, otherwise JitsiTrack objects will be returned.
+     * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with
+     * the following structure {stream: the Media Stream, type: "audio" or
+     * "video", videoType: "camera" or "desktop"} will be returned trough the
+     * Promise, otherwise JitsiTrack objects will be returned.
      * @param {string} options.cameraDeviceId
      * @param {string} options.micDeviceId
      * @returns {*} Promise object that will receive the new JitsiTracks
                         dsOptions);
                 }
 
-                // With FF/IE we can't split the stream into audio and video because FF
-                // doesn't support media stream constructors. So, we need to get the
-                // audio stream separately from the video stream using two distinct GUM
-                // calls. Not very user friendly :-( but we don't have many other
-                // options neither.
+                // With FF/IE we can't split the stream into audio and video
+                // because FF doesn't support media stream constructors. So, we
+                // need to get the audio stream separately from the video stream
+                // using two distinct GUM calls. Not very user friendly :-( but
+                // we don't have many other options neither.
                 //
-                // Note that we pack those 2 streams in a single object and pass it to
-                // the successCallback method.
+                // Note that we pack those 2 streams in a single object and pass
+                // it to the successCallback method.
                 obtainDevices({
                     devices: options.devices,
                     streams: [],
                 const hasDesktop = options.devices.indexOf('desktop') > -1;
 
                 if (hasDesktop) {
-                    options.devices.splice(options.devices.indexOf('desktop'), 1);
+                    options.devices.splice(
+                        options.devices.indexOf('desktop'),
+                        1);
                 }
                 options.resolution = options.resolution || '360';
                 if (options.devices.length) {
                                 = stream.getVideoTracks().length > 0;
 
                             if ((audioDeviceRequested && !audioTracksReceived)
-                                || (videoDeviceRequested && !videoTracksReceived)) {
+                                    || (videoDeviceRequested
+                                        && !videoTracksReceived)) {
                                 self.stopMediaStream(stream);
 
                                 // We are getting here in case if we requested
                                 // this happened, so reject with general error.
                                 const devices = [];
 
-                                if (audioDeviceRequested && !audioTracksReceived) {
+                                if (audioDeviceRequested
+                                        && !audioTracksReceived) {
                                     devices.push('audio');
                                 }
 
-                                if (videoDeviceRequested && !videoTracksReceived) {
+                                if (videoDeviceRequested
+                                        && !videoTracksReceived) {
                                     devices.push('video');
                                 }
 
                                         reject(new JitsiTrackError(
                                             { name: 'UnknownError' },
                                             getConstraints(
-                                                options.devices, options),
+                                                options.devices,
+                                                options),
                                             devices)
                                         );
                                     },

modules/RTC/TraceablePeerConnection.js

 TraceablePeerConnection.prototype._remoteStreamAdded = function(stream) {
     if (!RTC.isUserStream(stream)) {
         logger.info(
-            'Ignored remote \'stream added\' event for non-user stream', stream);
+            'Ignored remote \'stream added\' event for non-user stream',
+            stream);
 
         return;
     }
     const session = transform.parse(desc.sdp);
 
     if (typeof session !== 'undefined'
-        && typeof session.media !== 'undefined' && Array.isArray(session.media)) {
+            && typeof session.media !== 'undefined'
+            && Array.isArray(session.media)) {
         session.media.forEach(mLine => {
 
             // Chrome appears to be picky about the order in which a=ssrc lines
 
 TraceablePeerConnection.prototype.setLocalDescription
         = function(description, successCallback, failureCallback) {
-            this.trace('setLocalDescription::preTransform', dumpSDP(description));
+            this.trace(
+                'setLocalDescription::preTransform',
+                dumpSDP(description));
 
-    // if we're running on FF, transform to Plan A first.
+            // if we're running on FF, transform to Plan A first.
             if (RTCBrowserType.usesUnifiedPlan()) {
                 description = this.interop.toUnifiedPlan(description);
                 this.trace('setLocalDescription::postTransform (Plan A)',
 
 TraceablePeerConnection.prototype.setRemoteDescription
         = function(description, successCallback, failureCallback) {
-            this.trace('setRemoteDescription::preTransform', dumpSDP(description));
+            this.trace(
+                'setRemoteDescription::preTransform',
+                dumpSDP(description));
 
-    // TODO the focus should squeze or explode the remote simulcast
+            // TODO the focus should squeze or explode the remote simulcast
             description = this.simulcast.mungeRemoteDescription(description);
             this.trace(
-        'setRemoteDescription::postTransform (simulcast)',
-        dumpSDP(description));
+                'setRemoteDescription::postTransform (simulcast)',
+                dumpSDP(description));
 
             if (this.options.preferH264) {
                 const parsedSdp = transform.parse(description.sdp);
-                const videoMLine = parsedSdp.media.find(m => m.type === 'video');
+                const videoMLine
+                    = parsedSdp.media.find(m => m.type === 'video');
 
                 SDPUtil.preferVideoCodec(videoMLine, 'h264');
                 description.sdp = transform.write(parsedSdp);
             }
 
-    // if we're running on FF, transform to Plan A first.
+            // if we're running on FF, transform to Plan A first.
             if (RTCBrowserType.usesUnifiedPlan()) {
                 description.sdp = this.rtxModifier.stripRtx(description.sdp);
-                this.trace('setRemoteDescription::postTransform (stripRtx)', dumpSDP(description));
+                this.trace(
+                    'setRemoteDescription::postTransform (stripRtx)',
+                    dumpSDP(description));
                 description = this.interop.toUnifiedPlan(description);
                 this.trace(
             'setRemoteDescription::postTransform (Plan A)',
                         = this.sdpConsistency.makeVideoPrimarySsrcsConsistent(
                             answer.sdp);
                     this.trace(
-                        'createAnswerOnSuccess::postTransform (make primary video ssrcs consistent)',
+                        'createAnswerOnSuccess::postTransform (make primary'
+                          + ' video ssrcs consistent)',
                         dumpSDP(answer));
                 }
 

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;
     }
 
 
         const bytesReceivedNow = getNonNegativeStat(now, 'bytesReceived');
         const bytesReceivedBefore = getNonNegativeStat(before, 'bytesReceived');
-        const bytesReceived = Math.max(0, bytesReceivedNow - bytesReceivedBefore);
+        const bytesReceived
+            = Math.max(0, bytesReceivedNow - bytesReceivedBefore);
 
         let bytesSent = 0;
 

modules/statistics/statistics.js

 };
 
 Statistics.prototype.removeConnectionStatsListener = function(listener) {
-    this.eventEmitter.removeListener(StatisticsEvents.CONNECTION_STATS, listener);
+    this.eventEmitter.removeListener(
+        StatisticsEvents.CONNECTION_STATS,
+        listener);
 };
 
 Statistics.prototype.addByteSentStatsListener = function(listener) {

modules/xmpp/ChatRoom.js

         this.focusMucJid = null;
         this.noBridgeAvailable = false;
         this.options = options || {};
-        this.moderator = new Moderator(this.roomjid, this.xmpp, this.eventEmitter,
-            { connection: this.xmpp.options,
-                conference: this.options });
+        this.moderator
+            = new Moderator(this.roomjid, this.xmpp, this.eventEmitter, {
+                connection: this.xmpp.options,
+                conference: this.options
+            });
         this.initPresenceMap();
         this.lastPresences = {};
         this.phoneNumber = null;
             'attributes': { xmlns: 'http://jitsi.org/jitmeet/user-agent' }
         });
 
-        // We need to broadcast 'videomuted' status from the beginning, cause Jicofo
-        // makes decisions based on that. Initialize it with 'false' here.
+        // We need to broadcast 'videomuted' status from the beginning, cause
+        // Jicofo makes decisions based on that. Initialize it with 'false'
+        // here.
         this.addVideoInfoToPresence(false);
     }
 
         const pres = $pres({ to });
 
         // xep-0045 defines: "including in the initial presence stanza an empty
-        // <x/> element qualified by the 'http://jabber.org/protocol/muc' namespace"
-        // and subsequent presences should not include that or it can be considered
-        // as joining, and server can send us the message history for the room on
-        // every presence
+        // <x/> element qualified by the 'http://jabber.org/protocol/muc'
+        // namespace" and subsequent presences should not include that or it can
+        // be considered as joining, and server can send us the message history
+        // for the room on every presence
         if (fromJoin) {
             pres.c('x', { xmlns: this.presMap.xns });
 
         if (fromJoin) {
             // XXX We're pressed for time here because we're beginning a complex
             // and/or lengthy conference-establishment process which supposedly
-            // involves multiple RTTs. We don't have the time to wait for Strophe to
-            // decide to send our IQ.
+            // involves multiple RTTs. We don't have the time to wait for
+            // Strophe to decide to send our IQ.
             this.connection.flush();
         }
     }
         this.presMap.length = 0;
 
         // XXX Strophe is asynchronously sending by default. Unfortunately, that
-        // means that there may not be enough time to send the unavailable presence.
-        // Switching Strophe to synchronous sending is not much of an option because
-        // it may lead to a noticeable delay in navigating away from the current
-        // location. As a compromise, we will try to increase the chances of sending
-        // the unavailable presence within the short time span that we have upon
-        // unloading by invoking flush() on the connection. We flush() once before
-        // sending/queuing the unavailable presence in order to attemtp to have the
-        // unavailable presence at the top of the send queue. We flush() once more
-        // after sending/queuing the unavailable presence in order to attempt to
-        // have it sent as soon as possible.
+        // means that there may not be enough time to send the unavailable
+        // presence. Switching Strophe to synchronous sending is not much of an
+        // option because it may lead to a noticeable delay in navigating away
+        // from the current location. As a compromise, we will try to increase
+        // the chances of sending the unavailable presence within the short time
+        // span that we have upon unloading by invoking flush() on the
+        // connection. We flush() once before sending/queuing the unavailable
+        // presence in order to attemtp to have the unavailable presence at the
+        // top of the send queue. We flush() once more after sending/queuing the
+        // unavailable presence in order to attempt to have it sent as soon as
+        // possible.
         this.connection.flush();
         this.connection.send(pres);
         this.connection.flush();
         }
 
         if (from == this.myroomjid) {
-            const newRole = member.affiliation == 'owner' ? member.role : 'none';
+            const newRole
+                = member.affiliation == 'owner' ? member.role : 'none';
 
             if (this.role !== newRole) {
                 this.role = newRole;
-                this.eventEmitter.emit(XMPPEvents.LOCAL_ROLE_CHANGED, this.role);
+                this.eventEmitter.emit(
+                    XMPPEvents.LOCAL_ROLE_CHANGED,
+                    this.role);
             }
             if (!this.joined) {
                 this.joined = true;
 
             if (member.isFocus) {
                 // From time to time first few presences of the focus are not
-                // containing it's jid. That way we can mark later the focus member
-                // instead of not marking it at all and not starting the conference.
-                // FIXME: Maybe there is a better way to handle this issue. It seems
-                // there is some period of time in prosody that the configuration
-                // form is received but not applied. And if any participant joins
-                // during that period of time the first presence from the focus
-                // won't conain <item jid="focus..." />.
+                // containing it's jid. That way we can mark later the focus
+                // member instead of not marking it at all and not starting the
+                // conference.
+                // FIXME: Maybe there is a better way to handle this issue. It
+                // seems there is some period of time in prosody that the
+                // configuration form is received but not applied. And if any
+                // participant joins during that period of time the first
+                // presence from the focus won't conain <item jid="focus..." />.
                 memberOfThis.isFocus = true;
                 this._initFocus(from, jid);
             }
 
                     if (displayName && displayName.length > 0) {
                         this.eventEmitter.emit(
-                                XMPPEvents.DISPLAY_NAME_CHANGED, from, displayName);
+                            XMPPEvents.DISPLAY_NAME_CHANGED,
+                            from,
+                            displayName);
                     }
                 }
                 break;
     }
 
     /**
-     * Sets the special listener to be used for "command"s whose name starts with
-     * "jitsi_participant_".
+     * Sets the special listener to be used for "command"s whose name starts
+     * with "jitsi_participant_".
      */
     setParticipantPropertyListener(listener) {
         this.participantPropertyListener = listener;
 
         msg.c('body', body).up();
         if (nickname) {
-            msg.c('nick', { xmlns: 'http://jabber.org/protocol/nick' }).t(nickname).up().up();
+            msg.c('nick', { xmlns: 'http://jabber.org/protocol/nick' })
+                .t(nickname)
+                .up()
+                .up();
         }
         this.connection.send(msg);
         this.eventEmitter.emit(XMPPEvents.SENDING_CHAT_MESSAGE, body);
         }
 
         // Status code 110 indicates that this notification is "self-presence".
-        const isSelfPresence = $(pres).find(
-                '>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="110"]'
-            ).length !== 0;
-        const isKick = $(pres).find(
-                '>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="307"]'
-            ).length !== 0;
+        const isSelfPresence
+            = $(pres)
+                    .find(
+                        '>x[xmlns="http://jabber.org/protocol/muc#user"]>'
+                            + 'status[code="110"]')
+                    .length
+                !== 0;
+        const isKick
+            = $(pres)
+                    .find(
+                        '>x[xmlns="http://jabber.org/protocol/muc#user"]'
+                            + '>status[code="307"]')
+                    .length
+                !== 0;
         const membersKeys = Object.keys(this.members);
 
         if (!isSelfPresence) {
 
             if (stamp) {
                 // the format is CCYYMMDDThh:mm:ss
-                const dateParts = stamp.match(/(\d{4})(\d{2})(\d{2}T\d{2}:\d{2}:\d{2})/);
+                const dateParts
+                    = stamp.match(/(\d{4})(\d{2})(\d{2}T\d{2}:\d{2}:\d{2})/);
 
                 stamp = `${dateParts[1]}-${dateParts[2]}-${dateParts[3]}Z`;
             }
         }
 
-        if (from == this.roomjid && $(msg).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="104"]').length) {
+        if (from == this.roomjid
+                && $(msg)
+                    .find(
+                        '>x[xmlns="http://jabber.org/protocol/muc#user"]'
+                            + '>status[code="104"]')
+                    .length) {
             this.discoRoomInfo();
         }
 
     }
 
     onPresenceError(pres, from) {
-        if ($(pres).find('>error[type="auth"]>not-authorized[xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"]').length) {
+        if ($(pres)
+                .find(
+                    '>error[type="auth"]'
+                        + '>not-authorized['
+                        + 'xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"]')
+                .length) {
             logger.log('on password required', from);
             this.eventEmitter.emit(XMPPEvents.PASSWORD_REQUIRED);
-        } else if ($(pres).find(
-            '>error[type="cancel"]>not-allowed[xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"]').length) {
+        } else if ($(pres)
+                .find(
+                    '>error[type="cancel"]'
+                        + '>not-allowed['
+                        + 'xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"]')
+                .length) {
             const toDomain = Strophe.getDomainFromJid(pres.getAttribute('to'));
 
             if (toDomain === this.xmpp.options.hosts.anonymousdomain) {
 
             } else {
                 logger.warn('onPresError ', pres);
-                this.eventEmitter.emit(XMPPEvents.ROOM_CONNECT_NOT_ALLOWED_ERROR);
+                this.eventEmitter.emit(
+                    XMPPEvents.ROOM_CONNECT_NOT_ALLOWED_ERROR);
             }
         } else if ($(pres).find('>error>service-unavailable').length) {
             logger.warn('Maximum users limit for the room has been reached',
     lockRoom(key, onSuccess, onError, onNotSupported) {
         // http://xmpp.org/extensions/xep-0045.html#roomconfig
         this.connection.sendIQ(
-            $iq({ to: this.roomjid,
-                type: 'get' }).c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' }),
+            $iq({
+                to: this.roomjid,
+                type: 'get'
+            })
+                .c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' }),
             res => {
-                if ($(res).find('>query>x[xmlns="jabber:x:data"]>field[var="muc#roomconfig_roomsecret"]').length) {
+                if ($(res)
+                        .find(
+                            '>query>x[xmlns="jabber:x:data"]'
+                                + '>field[var="muc#roomconfig_roomsecret"]')
+                        .length) {
                     const formsubmit
-                        = $iq({ to: this.roomjid,
-                            type: 'set' })
-                            .c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' });
-
-                    formsubmit.c('x', { xmlns: 'jabber:x:data',
-                        type: 'submit' });
-                    formsubmit.c('field', { 'var': 'FORM_TYPE' }).c('value').t('http://jabber.org/protocol/muc#roomconfig').up().up();
-                    formsubmit.c('field', { 'var': 'muc#roomconfig_roomsecret' }).c('value').t(key).up().up();
-
-                    // Fixes a bug in prosody 0.9.+ https://code.google.com/p/lxmppd/issues/detail?id=373
-                    formsubmit.c('field', { 'var': 'muc#roomconfig_whois' }).c('value').t('anyone').up().up();
+                        = $iq({
+                            to: this.roomjid,
+                            type: 'set'
+                        })
+                            .c('query', {
+                                xmlns: 'http://jabber.org/protocol/muc#owner'
+                            });
+
+                    formsubmit.c('x', {
+                        xmlns: 'jabber:x:data',
+                        type: 'submit'
+                    });
+                    formsubmit
+                        .c('field', { 'var': 'FORM_TYPE' })
+                        .c('value')
+                        .t('http://jabber.org/protocol/muc#roomconfig')
+                        .up()
+                        .up();
+                    formsubmit
+                        .c('field', { 'var': 'muc#roomconfig_roomsecret' })
+                        .c('value')
+                        .t(key)
+                        .up()
+                        .up();
+
+                    // Fixes a bug in prosody 0.9.+
+                    // https://code.google.com/p/lxmppd/issues/detail?id=373
+                    formsubmit
+                        .c('field', { 'var': 'muc#roomconfig_whois' })
+                        .c('value')
+                        .t('anyone')
+                        .up()
+                        .up();
 
                     // FIXME: is muc#roomconfig_passwordprotectedroom required?
                     this.connection.sendIQ(formsubmit, onSuccess, onError);
      * Checks if the user identified by given <tt>mucJid</tt> is the conference
      * focus.
      * @param mucJid the full MUC address of the user to be checked.
-     * @returns {boolean|null} <tt>true</tt> if MUC user is the conference focus or
-     * <tt>false</tt> if is not. When given <tt>mucJid</tt> does not exist in
+     * @returns {boolean|null} <tt>true</tt> if MUC user is the conference focus
+     * or <tt>false</tt> if is not. When given <tt>mucJid</tt> does not exist in
      * the MUC then <tt>null</tt> is returned.
      */
     isFocus(mucJid) {
     }
 
     /**
-     * Returns null if the recording is not supported, "on" if the recording started
-     * and "off" if the recording is not started.
+     * Returns null if the recording is not supported, "on" if the recording
+     * started and "off" if the recording is not started.
      */
     getRecordingState() {
         return this.recording ? this.recording.getState() : undefined;
     /**
      * Starts/stops the recording
      * @param token token for authentication
-     * @param statusChangeHandler {function} receives the new status as argument.
+     * @param statusChangeHandler {function} receives the new status as
+     * argument.
      */
     toggleRecording(options, statusChangeHandler) {
         if (this.recording) {
         if (mute.length) {
             const doMuteAudio = mute.text() === 'true';
 
-            this.eventEmitter.emit(XMPPEvents.AUDIO_MUTED_BY_FOCUS, doMuteAudio);
+            this.eventEmitter.emit(
+                XMPPEvents.AUDIO_MUTED_BY_FOCUS,
+                doMuteAudio);
         }
 
         return true;
 
     /**
      * Leaves the room. Closes the jingle session.
-     * @returns {Promise} which is resolved if XMPPEvents.MUC_LEFT is received less
-     * than 5s after sending presence unavailable. Otherwise the promise is
+     * @returns {Promise} which is resolved if XMPPEvents.MUC_LEFT is received
+     * less than 5s after sending presence unavailable. Otherwise the promise is
      * rejected.
      */
     leave() {

modules/xmpp/JingleSessionPC.js

                     finishedCallback();
                 }, error => {
                     logger.error(
-                        `Error renegotiating after processing remote source-add: ${error}`);
+                        'Error renegotiating after processing remote'
+                            + ` source-add: ${error}`);
                     finishedCallback(error);
                 });
         };
                     finishedCallback();
                 }, error => {
                     logger.error(
-                        `Error renegotiating after processing remote source-remove: ${error}`);
+                        'Error renegotiating after processing remote'
+                          + ` source-remove: ${error}`);
                     finishedCallback(error);
                 });
         };
                 remoteDescription,
                 () => {
                     if (this.signalingState === 'closed') {
-                        reject('Attempted to setRemoteDescription in state closed');
+                        reject(
+                            'Attempted to setRemoteDescription in state'
+                                + ' closed');
 
                         return;
                     }
         const workFunction = finishedCallback => {
             if (!this.peerconnection) {
                 finishedCallback(
-                    'Error: tried adding stream with no active peer connection');
+                    'Error: tried adding stream with no active peer'
+                        + ' connection');
 
                 return;
             }

modules/xmpp/SDP.js

 
     for (let mediaindex = 0; mediaindex < self.media.length; mediaindex++) {
         tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc:');
-        const mid = SDPUtil.parse_mid(SDPUtil.find_line(self.media[mediaindex], 'a=mid:'));
+        const mid
+            = SDPUtil.parse_mid(
+                SDPUtil.find_line(self.media[mediaindex],
+                'a=mid:'));
         const media = {
             mediaindex,
             mid,
                 elem.attrs({ ssrc });
             }
             for (j = 0; j < mline.fmt.length; j++) {
-                rtpmap = SDPUtil.find_line(this.media[i], `a=rtpmap:${mline.fmt[j]}`);
+                rtpmap
+                    = SDPUtil.find_line(
+                        this.media[i],
+                        `a=rtpmap:${mline.fmt[j]}`);
                 elem.c('payload-type', SDPUtil.parse_rtpmap(rtpmap));
 
-                // put any 'a=fmtp:' + mline.fmt[j] lines into <param name=foo value=bar/>
-                const afmtpline = SDPUtil.find_line(this.media[i], `a=fmtp:${mline.fmt[j]}`);
+                // put any 'a=fmtp:' + mline.fmt[j] lines into <param name=foo
+                // value=bar/>
+                const afmtpline
+                    = SDPUtil.find_line(
+                        this.media[i],
+                        `a=fmtp:${mline.fmt[j]}`);
 
                 if (afmtpline) {
                     tmp = SDPUtil.parse_fmtp(afmtpline);
                         elem.c('parameter', tmp[k]).up();
                     }
                 }
-                this.rtcpFbToJingle(i, elem, mline.fmt[j]); // XEP-0293 -- map a=rtcp-fb
+
+                // XEP-0293 -- map a=rtcp-fb
+                this.rtcpFbToJingle(i, elem, mline.fmt[j]);
 
                 elem.up();
             }
-            const crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
+            const crypto
+                = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
 
             if (crypto.length) {
                 elem.c('encryption', { required: 1 });
                 elem.up();
 
                 // XEP-0339 handle ssrc-group attributes
-                const ssrc_group_lines = SDPUtil.find_lines(this.media[i], 'a=ssrc-group:');
+                const ssrc_group_lines
+                    = SDPUtil.find_lines(this.media[i], 'a=ssrc-group:');
 
                 ssrc_group_lines.forEach(line => {
                     const idx = line.indexOf(' ');
             if (lines.length) {
                 for (j = 0; j < lines.length; j++) {
                     tmp = SDPUtil.parse_extmap(lines[j]);
-                    elem.c('rtp-hdrext', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtp-hdrext:0',
+                    elem.c('rtp-hdrext', {
+                        xmlns: 'urn:xmpp:jingle:apps:rtp:rtp-hdrext:0',
                         uri: tmp.uri,
-                        id: tmp.value });
+                        id: tmp.value
+                    });
                     if (tmp.hasOwnProperty('direction')) {
                         switch (tmp.direction) {
                         case 'sendonly':
         // map ice-ufrag/pwd, dtls fingerprint, candidates
         this.transportToJingle(i, elem);
 
-        if (SDPUtil.find_line(this.media[i], 'a=sendrecv', this.session)) {
+        const m = this.media[i];
+
+        if (SDPUtil.find_line(m, 'a=sendrecv', this.session)) {
             elem.attrs({ senders: 'both' });
-        } else if (SDPUtil.find_line(this.media[i], 'a=sendonly', this.session)) {
+        } else if (SDPUtil.find_line(m, 'a=sendonly', this.session)) {
             elem.attrs({ senders: 'initiator' });
-        } else if (SDPUtil.find_line(this.media[i], 'a=recvonly', this.session)) {
+        } else if (SDPUtil.find_line(m, 'a=recvonly', this.session)) {
             elem.attrs({ senders: 'responder' });
-        } else if (SDPUtil.find_line(this.media[i], 'a=inactive', this.session)) {
+        } else if (SDPUtil.find_line(m, 'a=inactive', this.session)) {
             elem.attrs({ senders: 'none' });
         }
         if (mline.port == '0') {
 
     // XEP-0320
     const fingerprints
-        = SDPUtil.find_lines(this.media[mediaindex], 'a=fingerprint:', this.session);
+        = SDPUtil.find_lines(
+            this.media[mediaindex],
+            'a=fingerprint:',
+            this.session);
 
     fingerprints.forEach(line => {
         tmp = SDPUtil.parse_fingerprint(line);
         tmp.xmlns = 'urn:xmpp:jingle:apps:dtls:0';
         elem.c('fingerprint').t(tmp.fingerprint);
         delete tmp.fingerprint;
-        line = SDPUtil.find_line(self.media[mediaindex], 'a=setup:', self.session);
+        line
+            = SDPUtil.find_line(
+                self.media[mediaindex],
+                'a=setup:',
+                self.session);
         if (line) {
             tmp.setup = line.substr(8);
         }
         elem.attrs(tmp);
 
         // XEP-0176
-        if (SDPUtil.find_line(this.media[mediaindex], 'a=candidate:', this.session)) { // add any a=candidate lines
-            const lines = SDPUtil.find_lines(this.media[mediaindex], 'a=candidate:', this.session);
+        const lines
+            = SDPUtil.find_lines(
+                this.media[mediaindex],
+                'a=candidate:',
+                this.session);
 
+        if (lines.length) { // add any a=candidate lines
             lines.forEach(line => {
                 const candidate = SDPUtil.candidateToJingle(line);
 
                 if (self.failICE) {
                     candidate.ip = '1.1.1.1';
                 }
-                const protocol = candidate
-                        && typeof candidate.protocol === 'string'
-                    ? candidate.protocol.toLowerCase() : '';
+                const protocol
+                    = candidate && typeof candidate.protocol === 'string'
+                        ? candidate.protocol.toLowerCase()
+                        : '';
 
                 if ((self.removeTcpCandidates
                         && (protocol === 'tcp' || protocol === 'ssltcp'))
     elem.up(); // end of transport
 };
 
-SDP.prototype.rtcpFbToJingle = function(mediaindex, elem, payloadtype) { // XEP-0293
-    const lines = SDPUtil.find_lines(this.media[mediaindex], `a=rtcp-fb:${payloadtype}`);
+// XEP-0293
+SDP.prototype.rtcpFbToJingle = function(mediaindex, elem, payloadtype) {
+    const lines
+        = SDPUtil.find_lines(
+            this.media[mediaindex],
+            `a=rtcp-fb:${payloadtype}`);
 
     lines.forEach(line => {
         const tmp = SDPUtil.parse_rtcpfb(line);
 
         if (tmp.type == 'trr-int') {
-            elem.c('rtcp-fb-trr-int', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0',
-                value: tmp.params[0] });
+            elem.c('rtcp-fb-trr-int', {
+                xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0',
+                value: tmp.params[0]
+            });
             elem.up();
         } else {
-            elem.c('rtcp-fb', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0',
-                type: tmp.type });
+            elem.c('rtcp-fb', {
+                xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0',
+                type: tmp.type
+            });
             if (tmp.params.length > 0) {
                 elem.attrs({ 'subtype': tmp.params[0] });
             }
 
 SDP.prototype.rtcpFbFromJingle = function(elem, payloadtype) { // XEP-0293
     let media = '';
-    let tmp = elem.find('>rtcp-fb-trr-int[xmlns="urn:xmpp:jingle:apps:rtp:rtcp-fb:0"]');
+    let tmp
+        = elem.find(
+            '>rtcp-fb-trr-int[xmlns="urn:xmpp:jingle:apps:rtp:rtcp-fb:0"]');
 
     if (tmp.length) {
         media += 'a=rtcp-fb:* trr-int ';
         + 's=-\r\n'
         + 't=0 0\r\n';
 
-    // http://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-04#section-8
+    // http://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-04
+    // #section-8
     const groups
         = $(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]');
 
 
             if (contents.length > 0) {
                 self.raw
-                    += `a=group:${group.getAttribute('semantics') || group.getAttribute('type')} ${contents.join(' ')}\r\n`;
+                    += `a=group:${
+                        group.getAttribute('semantics')
+                            || group.getAttribute('type')} ${
+                        contents.join(' ')}\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"]');
+    tmp
+        = content.find(
+            '>transport[xmlns="urn:xmpp:jingle:transports:ice-udp:1"]');
     if (tmp.length) {
         if (tmp.attr('ufrag')) {
             media += `${SDPUtil.build_iceufrag(tmp.attr('ufrag'))}\r\n`;
     media += `a=mid:${content.attr('name')}\r\n`;
 
     // <description><rtcp-mux/></description>
-    // see http://code.google.com/p/libjingle/issues/detail?id=309 -- no spec though
+    // see http://code.google.com/p/libjingle/issues/detail?id=309 -- no spec
+    // though
     // and http://mail.jabber.org/pipermail/jingle/2011-December/001761.html
     if (desc.find('rtcp-mux').length) {
         media += 'a=rtcp-mux\r\n';
     media += self.rtcpFbFromJingle(desc, '*');
 
     // xep-0294
-    tmp = desc.find('>rtp-hdrext[xmlns="urn:xmpp:jingle:apps:rtp:rtp-hdrext:0"]');
+    tmp
+        = desc.find(
+            '>rtp-hdrext[xmlns="urn:xmpp:jingle:apps:rtp:rtp-hdrext:0"]');
     tmp.each(function() {
-        media += `a=extmap:${this.getAttribute('id')} ${this.getAttribute('uri')}\r\n`;
+        media
+            += `a=extmap:${this.getAttribute('id')} ${
+                this.getAttribute('uri')}\r\n`;
     });
 
-    content.find('>transport[xmlns="urn:xmpp:jingle:transports:ice-udp:1"]>candidate').each(function() {
-        let protocol = this.getAttribute('protocol');
-
-        protocol = typeof protocol === 'string' ? protocol.toLowerCase() : '';
-
-        if ((self.removeTcpCandidates
-                && (protocol === 'tcp' || protocol === 'ssltcp'))
-            || (self.removeUdpCandidates && protocol === 'udp')) {
-            return;
-        } else if (self.failICE) {
-            this.setAttribute('ip', '1.1.1.1');
-        }
+    content
+        .find(
+            '>transport[xmlns="urn:xmpp:jingle:transports:ice-udp:1"]'
+                + '>candidate')
+        .each(function() {
+            let protocol = this.getAttribute('protocol');
+
+            protocol
+                = typeof protocol === 'string' ? protocol.toLowerCase() : '';
+
+            if ((self.removeTcpCandidates
+                    && (protocol === 'tcp' || protocol === 'ssltcp'))
+                || (self.removeUdpCandidates && protocol === 'udp')) {
+                return;
+            } else if (self.failICE) {
+                this.setAttribute('ip', '1.1.1.1');
+            }
 
-        media += SDPUtil.candidateFromJingle(this);
-    });
+            media += SDPUtil.candidateFromJingle(this);
+        });
 
     // XEP-0339 handle ssrc-group attributes
-    content.find('description>ssrc-group[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]').each(function() {
-        const semantics = this.getAttribute('semantics');
-        const ssrcs
-            = $(this)
-                .find('>source')
-                .map(function() {
-                    return this.getAttribute('ssrc');
-                })
-                .get();
+    content
+        .find('description>ssrc-group[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]')
+        .each(function() {
+            const semantics = this.getAttribute('semantics');
+            const ssrcs
+                = $(this)
+                    .find('>source')
+                    .map(function() {
+                        return this.getAttribute('ssrc');
+                    })
+                    .get();
 
-        if (ssrcs.length) {
-            media += `a=ssrc-group:${semantics} ${ssrcs.join(' ')}\r\n`;
-        }
-    });
+            if (ssrcs.length) {
+                media += `a=ssrc-group:${semantics} ${ssrcs.join(' ')}\r\n`;
+            }
+        });
 
-    tmp = content.find('description>source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
+    tmp
+        = content.find(
+            'description>source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
     tmp.each(function() {
         const ssrc = this.getAttribute('ssrc');
 

modules/xmpp/SDPUtil.js

         let pwd, ufrag;
 
         if ((ufrag = SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc))
-                && (pwd = SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc))) {
+                && (pwd
+                    = SDPUtil.find_line(
+                        mediadesc,
+                        'a=ice-pwd:',
+                        sessiondesc))) {
             data = {
                 ufrag: SDPUtil.parse_iceufrag(ufrag),
                 pwd: SDPUtil.parse_icepwd(pwd)
         return data;
     },
     build_mline(mline) {
-        return `m=${mline.media} ${mline.port} ${mline.proto} ${mline.fmt.join(' ')}`;
+        return (
+            `m=${mline.media} ${mline.port} ${mline.proto} ${
+                mline.fmt.join(' ')}`);
     },
     parse_rtpmap(line) {
         const data = {};
         return [ sctpPort, protocol, streamCount ];// SCTP port
     },
     build_rtpmap(el) {
-        let line = `a=rtpmap:${el.getAttribute('id')} ${el.getAttribute('name')}/${el.getAttribute('clockrate')}`;
+        let line
+            = `a=rtpmap:${el.getAttribute('id')} ${el.getAttribute('name')}/${
+                el.getAttribute('clockrate')}`;
 
         if (el.getAttribute('channels') && el.getAttribute('channels') != '1') {
             line += `/${el.getAttribute('channels')}`;
                 candidate.tcptype = elems[i + 1];
                 break;
             default: // TODO
-                logger.log(`parse_icecandidate not translating "${elems[i]}" = "${elems[i + 1]}"`);
+                logger.log(
+                    `parse_icecandidate not translating "${
+                        elems[i]}" = "${elems[i + 1]}"`);
             }
         }
         candidate.network = '1';
         return candidate;
     },
     build_icecandidate(cand) {
-        let line = [ `a=candidate:${cand.foundation}`, cand.component, cand.protocol, cand.priority, cand.ip, cand.port, 'typ', cand.type ].join(' ');
+        let line = [
+            `a=candidate:${cand.foundation}`,
+            cand.component,
+            cand.protocol,
+            cand.priority,
+            cand.ip,
+            cand.port,
+            'typ',
+            cand.type
+        ].join(' ');
 
         line += ' ';
         switch (cand.type) {
         case 'srflx':
         case 'prflx':
         case 'relay':
-            if (cand.hasOwnAttribute('rel-addr') && cand.hasOwnAttribute('rel-port')) {
+            if (cand.hasOwnAttribute('rel-addr')
+                    && cand.hasOwnAttribute('rel-port')) {
                 line += 'raddr';
                 line += ' ';
                 line += cand['rel-addr'];
     },
     parse_ssrc(desc) {
         // proprietary mapping of a=ssrc lines
-        // TODO: see "Jingle RTP Source Description" by Juberti and P. Thatcher on google docs
-        // and parse according to that
+        // TODO: see "Jingle RTP Source Description" by Juberti and P. Thatcher
+        // on google docs and parse according to that
         const data = {};
         const lines = desc.split('\r\n');
 
             if (lines[i].substring(0, 7) == 'a=ssrc:') {
                 const idx = lines[i].indexOf(' ');
 
-                data[lines[i].substr(idx + 1).split(':', 2)[0]] = lines[i].substr(idx + 1).split(':', 2)[1];
+                data[lines[i].substr(idx + 1).split(':', 2)[0]]
+                    = lines[i].substr(idx + 1).split(':', 2)[1];
             }
         }
 
         return needles;
     },
     candidateToJingle(line) {
-        // a=candidate:2979166662 1 udp 2113937151 192.168.2.100 57698 typ host generation 0
-        //      <candidate component=... foundation=... generation=... id=... ip=... network=... port=... priority=... protocol=... type=.../>
+        // a=candidate:2979166662 1 udp 2113937151 192.168.2.100 57698 typ host
+        // generation 0
+        //      <candidate component=... foundation=... generation=... id=...
+        // ip=... network=... port=... priority=... protocol=... type=.../>
         if (line.indexOf('candidate:') === 0) {
             line = `a=${line}`;
         } else if (line.substring(0, 12) != 'a=candidate:') {
-            logger.log('parseCandidate called with a line that is not a candidate line');
+            logger.log(
+                'parseCandidate called with a line that is not a candidate'
+                    + ' line');
             logger.log(line);
 
             return null;
         case 'srflx':
         case 'prflx':
         case 'relay':
-            if (cand.getAttribute('rel-addr') && cand.getAttribute('rel-port')) {
+            if (cand.getAttribute('rel-addr')
+                    && cand.getAttribute('rel-port')) {
                 line += 'raddr';
                 line += ' ';
                 line += cand.getAttribute('rel-addr');
             }
         }
         if (payloadType) {
-            const payloadTypes = videoMLine.payloads.split(' ').map(p => parseInt(p));
+            const payloadTypes
+                = videoMLine.payloads.split(' ').map(p => parseInt(p));
             const payloadIndex = payloadTypes.indexOf(payloadType);
 
             payloadTypes.splice(payloadIndex, 1);

modules/xmpp/strophe.jingle.js

                 ack.attrs({ type: 'error' });
                 ack.c('error', { type: 'cancel' })
                     .c('item-not-found', {
-                        xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' }).up()
-                    .c('unknown-session', { xmlns: 'urn:xmpp:jingle:errors:1' });
+                        xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'
+                    })
+                    .up()
+                    .c('unknown-session', {
+                        xmlns: 'urn:xmpp:jingle:errors:1'
+                    });
                 logger.warn('invalid session id', iq);
                 this.connection.send(ack);
 
                     'jid mismatch for session id', sid, sess.peerjid, iq);
                 ack.attrs({ type: 'error' });
                 ack.c('error', { type: 'cancel' })
-                    .c('item-not-found', { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' }).up()
-                    .c('unknown-session', { xmlns: 'urn:xmpp:jingle:errors:1' });
+                    .c('item-not-found', {
+                        xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'
+                    })
+                    .up()
+                    .c('unknown-session', {
+                        xmlns: 'urn:xmpp:jingle:errors:1'
+                    });
                 this.connection.send(ack);
 
                 return true;
             }
         } else if (sess !== undefined) {
-            // existing session with same session id
-            // this might be out-of-order if the sess.peerjid is the same as from
+            // Existing session with same session id. This might be out-of-order
+            // if the sess.peerjid is the same as from.
             ack.attrs({ type: 'error' });
             ack.c('error', { type: 'cancel' })
-                .c('service-unavailable', { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' }).up();
+                .c('service-unavailable', {
+                    xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'
+                })
+                .up();
             logger.warn('duplicate session id', sid, iq);
             this.connection.send(ack);
 
         // uses time-limited credentials as described in
         // http://tools.ietf.org/html/draft-uberti-behave-turn-rest-00
         //
-        // see https://code.google.com/p/prosody-modules/source/browse/mod_turncredentials/mod_turncredentials.lua
-        // for a prosody module which implements this
+        // See https://code.google.com/p/prosody-modules/source/browse/
+        // mod_turncredentials/mod_turncredentials.lua
+        // for a prosody module which implements this.
         //
-        // currently, this doesn't work with updateIce and therefore credentials with a long
-        // validity have to be fetched before creating the peerconnection
+        // Currently, this doesn't work with updateIce and therefore credentials
+        // with a long validity have to be fetched before creating the
+        // peerconnection.
         // TODO: implement refresh via updateIce as described in
         //      https://code.google.com/p/webrtc/issues/detail?id=1650
         this.connection.sendIQ(
                         dict.url = `${type}:`;
                         const username = el.attr('username');
 
-                            // https://code.google.com/p/webrtc/issues/detail?id=1508
+                        // https://code.google.com/p/webrtc/issues/detail
+                        // ?id=1508
 
                         if (username) {
                             if (navigator.userAgent.match(

modules/xmpp/xmpp.js

 
         // Setup a disconnect on unload as a way to facilitate API consumers. It
         // sounds like they would want that. A problem for them though may be if
-        // they wanted to utilize the connected connection in an unload handler of
-        // their own. However, it should be fairly easy for them to do that by
-        // registering their unload handler before us.
+        // they wanted to utilize the connected connection in an unload handler
+        // of their own. However, it should be fairly easy for them to do that
+        // by registering their unload handler before us.
         $(window).on('beforeunload unload', this.disconnect.bind(this));
     }
 
     /**
-     * Initializes the list of feature advertised through the disco-info mechanism
+     * Initializes the list of feature advertised through the disco-info
+     * mechanism.
      */
     initFeaturesList() {
         // http://xmpp.org/extensions/xep-0167.html#support
     }
 
     /**
-     * Attach to existing connection. Can be used for optimizations. For example:
-     * if the connection is created on the server we can attach to it and start
-     * using it.
+     * Attach to existing connection. Can be used for optimizations. For
+     * example: if the connection is created on the server we can attach to it
+     * and start using it.
      *
      * @param options {object} connecting options - rid, sid, jid and password.
      */
     /**
      * Disconnects this from the XMPP server (if this is connected).
      *
-     * @param ev optionally, the event which triggered the necessity to disconnect
-     * from the XMPP server (e.g. beforeunload, unload)
+     * @param ev optionally, the event which triggered the necessity to
+     * disconnect from the XMPP server (e.g. beforeunload, unload).
      */
     disconnect(ev) {
         if (this.disconnectInProgress
         this.disconnectInProgress = true;
 
         // XXX Strophe is asynchronously sending by default. Unfortunately, that
-        // means that there may not be enough time to send an unavailable presence
-        // or disconnect at all. Switching Strophe to synchronous sending is not
-        // much of an option because it may lead to a noticeable delay in navigating
-        // away from the current location. As a compromise, we will try to increase
-        // the chances of sending an unavailable presence and/or disconecting within
-        // the short time span that we have upon unloading by invoking flush() on
-        // the connection. We flush() once before disconnect() in order to attemtp
-        // to have its unavailable presence at the top of the send queue. We flush()
-        // once more after disconnect() in order to attempt to have its unavailable
-        // presence sent as soon as possible.
+        // means that there may not be enough time to send an unavailable
+        // presence or disconnect at all. Switching Strophe to synchronous
+        // sending is not much of an option because it may lead to a noticeable
+        // delay in navigating away from the current location. As a compromise,
+        // we will try to increase the chances of sending an unavailable
+        // presence and/or disconecting within the short time span that we have
+        // upon unloading by invoking flush() on the connection. We flush() once
+        // before disconnect() in order to attemtp to have its unavailable
+        // presence at the top of the send queue. We flush() once more after
+        // disconnect() in order to attempt to have its unavailable presence
+        // sent as soon as possible.
         this.connection.flush();
 
         if (ev !== null && typeof ev !== 'undefined') {
             if (evType == 'beforeunload' || evType == 'unload') {
                 // XXX Whatever we said above, synchronous sending is the best
                 // (known) way to properly disconnect from the XMPP server.
-                // Consequently, it may be fine to have the source code and comment
-                // it in or out depending on whether we want to run with it for some
-                // time.
+                // Consequently, it may be fine to have the source code and
+                // comment it in or out depending on whether we want to run with
+                // it for some time.
                 this.connection.options.sync = true;
             }
         }

service/RTC/CameraFacingMode.js

-/* global module */
 /**
  * The possible camera facing modes. For now support only 'user' and
  * 'environment' because 'left' and 'right' are not used anywhere in our
  * projects at the time of this writing. For more information please refer to
- * https://w3c.github.io/mediacapture-main/getusermedia.html#def-constraint-facingMode
+ * https://w3c.github.io/mediacapture-main/getusermedia.html
+ * #def-constraint-facingMode.
  *
  * @enum {string}
  */