[eslint] object-shorthand

.eslintrc.js

             { 'nestedBinaryExpressions': false }
         ],
 
+        'object-shorthand': [
+            'error',
+            'always',
+            { 'avoidQuotes': true }
+        ],
         'prefer-const': 2,
         'prefer-reflect': 0,
         'prefer-spread': 2,

JitsiConference.js

  * Sets a property for the local participant.
  */
 JitsiConference.prototype.setLocalParticipantProperty = function(name, value) {
-    this.sendCommand("jitsi_participant_" + name, {value: value});
+    this.sendCommand("jitsi_participant_" + name, {value});
 };
 
 /**

JitsiConferenceEventManager.js

             for (key in chatRoom.connectionTimes){
                 value = chatRoom.connectionTimes[key];
                 Statistics.analytics.sendEvent('conference.' + key,
-                    {value: value});
+                    {value});
             }
             for (key in chatRoom.xmpp.connectionTimes){
                 value = chatRoom.xmpp.connectionTimes[key];
                 Statistics.analytics.sendEvent('xmpp.' + key,
-                    {value: value});
+                    {value});
             }
     });
 
                 function (status, error) {
                     var logObject = {
                         id: "recorder_status",
-                        status: status
+                        status
                     };
                     if (error) {
                         logObject.error = error;

JitsiConnection.js

                 Statistics.analytics.sendEvent(
                     'connection.disconnected.' + msg);
             Statistics.sendLog(
-                JSON.stringify({id: "connection.disconnected", msg: msg}));
+                JSON.stringify({id: "connection.disconnected", msg}));
         });
 }
 
  * @returns {JitsiConference} returns the new conference object.
  */
 JitsiConnection.prototype.initJitsiConference = function (name, options) {
-    return new JitsiConference({name: name, config: options, connection: this});
+    return new JitsiConference({name, config: options, connection: this});
 };
 
 /**

JitsiMediaDevices.js

      * Executes callback with list of media devices connected.
      * @param {function} callback
      */
-    enumerateDevices: function (callback) {
+    enumerateDevices (callback) {
         RTC.enumerateDevices(callback);
     },
     /**
      * the WebRTC stack is ready, either with true if the device listing is
      * available available or with false otherwise.
      */
-    isDeviceListAvailable: function () {
+    isDeviceListAvailable () {
         return RTC.isDeviceListAvailable();
     },
     /**
      *      undefined or 'input', 'output' - for audio output device change.
      * @returns {boolean} true if available, false otherwise.
      */
-    isDeviceChangeAvailable: function (deviceType) {
+    isDeviceChangeAvailable (deviceType) {
         return RTC.isDeviceChangeAvailable(deviceType);
     },
     /**
      *      undefined stands for both 'audio' and 'video' together
      * @returns {boolean}
      */
-    isDevicePermissionGranted: function (type) {
+    isDevicePermissionGranted (type) {
         var permissions = RTC.getDeviceAvailability();
 
         switch(type) {
      * for default device
      * @returns {string}
      */
-    getAudioOutputDevice: function () {
+    getAudioOutputDevice () {
         return RTC.getAudioOutputDevice();
     },
     /**
      * @returns {Promise} - resolves when audio output is changed, is rejected
      *      otherwise
      */
-    setAudioOutputDevice: function (deviceId) {
+    setAudioOutputDevice (deviceId) {
 
         var availableDevices = RTC.getCurrentlyAvailableMediaDevices();
         if (availableDevices && availableDevices.length > 0)
      * @param {string} event - event name
      * @param {function} handler - event handler
      */
-    addEventListener: function (event, handler) {
+    addEventListener (event, handler) {
         eventEmitter.addListener(event, handler);
     },
     /**
      * @param {string} event - event name
      * @param {function} handler - event handler
      */
-    removeEventListener: function (event, handler) {
+    removeEventListener (event, handler) {
         eventEmitter.removeListener(event, handler);
     },
     /**
      * Emits an event.
      * @param {string} event - event name
      */
-    emitEvent: function (event) { // eslint-disable-line no-unused-vars
+    emitEvent (event) { // eslint-disable-line no-unused-vars
         eventEmitter.emit(...arguments);
     }
 };

JitsiMeetJS.js

 
     version: '{#COMMIT_HASH#}',
 
-    JitsiConnection: JitsiConnection,
+    JitsiConnection,
     events: {
         conference: JitsiConferenceEvents,
         connection: JitsiConnectionEvents,
         track: JitsiTrackErrors
     },
     errorTypes: {
-        JitsiTrackError: JitsiTrackError
+        JitsiTrackError
     },
     logLevels: Logger.levels,
     mediaDevices: JitsiMediaDevices,
     analytics: null,
-    init: function (options) {
+    init (options) {
         let logObject, attr;
         Statistics.init(options);
 
      * Returns whether the desktop sharing is enabled or not.
      * @returns {boolean}
      */
-    isDesktopSharingEnabled: function () {
+    isDesktopSharingEnabled () {
         return RTC.isDesktopSharingEnabled();
     },
-    setLogLevel: function (level) {
+    setLogLevel (level) {
         Logger.setLogLevel(level);
     },
     /**
      * Usually it's the name of the JavaScript source file including the path
      * ex. "modules/xmpp/ChatRoom.js"
      */
-    setLogLevelById: function (level, id) {
+    setLogLevelById (level, id) {
         Logger.setLogLevelById(level, id);
     },
     /**
      * @param globalTransport
      * @see Logger.addGlobalTransport
      */
-    addGlobalLogTransport: function (globalTransport) {
+    addGlobalLogTransport (globalTransport) {
         Logger.addGlobalTransport(globalTransport);
     },
     /**
      * @param globalTransport
      * @see Logger.removeGlobalTransport
      */
-    removeGlobalLogTransport: function (globalTransport) {
+    removeGlobalLogTransport (globalTransport) {
         Logger.removeGlobalTransport(globalTransport);
     },
     /**
      *     A promise that returns an array of created JitsiTracks if resolved,
      *     or a JitsiConferenceError if rejected.
      */
-    createLocalTracks: function (options, firePermissionPromptIsShownEvent) {
+    createLocalTracks (options, firePermissionPromptIsShownEvent) {
         var promiseFulfilled = false;
 
         if (firePermissionPromptIsShownEvent === true) {
      * available available or with false otherwise.
      * @deprecated use JitsiMeetJS.mediaDevices.isDeviceListAvailable instead
      */
-    isDeviceListAvailable: function () {
+    isDeviceListAvailable () {
         logger.warn('This method is deprecated, use ' +
             'JitsiMeetJS.mediaDevices.isDeviceListAvailable instead');
         return this.mediaDevices.isDeviceListAvailable();
      * @returns {boolean} true if available, false otherwise.
      * @deprecated use JitsiMeetJS.mediaDevices.isDeviceChangeAvailable instead
      */
-    isDeviceChangeAvailable: function (deviceType) {
+    isDeviceChangeAvailable (deviceType) {
         logger.warn('This method is deprecated, use ' +
             'JitsiMeetJS.mediaDevices.isDeviceChangeAvailable instead');
         return this.mediaDevices.isDeviceChangeAvailable(deviceType);
      * @param {function} callback
      * @deprecated use JitsiMeetJS.mediaDevices.enumerateDevices instead
      */
-    enumerateDevices: function (callback) {
+    enumerateDevices (callback) {
         logger.warn('This method is deprecated, use ' +
             'JitsiMeetJS.mediaDevices.enumerateDevices instead');
         this.mediaDevices.enumerateDevices(callback);
      * the function used by the lib.
      * (function(message, source, lineno, colno, error)).
      */
-    getGlobalOnErrorHandler: function (message, source, lineno, colno, error) {
+    getGlobalOnErrorHandler (message, source, lineno, colno, error) {
         logger.error(
             'UnhandledError: ' + message,
             'Script: ' + source,
      * Returns current machine id saved from the local storage.
      * @returns {string} the machine id
      */
-    getMachineId: function() {
+    getMachineId() {
         return Settings.getMachineId();
     },
 
      * interest to LibJitsiMeet clients.
      */
     util: {
-        ScriptUtil: ScriptUtil,
-        RTCUIHelper: RTCUIHelper,
-        AuthUtil: AuthUtil
+        ScriptUtil,
+        RTCUIHelper,
+        AuthUtil
     }
 };
 

modules/RTC/DataChannels.js

 DataChannels.prototype.sendDataChannelMessage = function (to, payload) {
     this.send({
         colibriClass: "EndpointMessage",
-        to: to,
+        to,
         msgPayload: payload
     });
 };

modules/RTC/RTCUIHelper.js

      * currently using.
      * @returns {string} 'video' or 'object' string name of WebRTC video element
      */
-    getVideoElementName: function () {
+    getVideoElementName () {
         return RTCBrowserType.isTemasysPluginUsed() ? 'object' : 'video';
     },
 
      * @returns {HTMLElement} video HTML element instance if found inside of the
      *          container or undefined otherwise.
      */
-    findVideoElement: function (containerElement) {
+    findVideoElement (containerElement) {
         var videoElemName = RTCUIHelper.getVideoElementName();
         if (!RTCBrowserType.isTemasysPluginUsed()) {
             return $(containerElement).find(videoElemName)[0];
      * @param streamElement HTML element to which the RTC stream is attached to.
      * @param volume the volume value to be set.
      */
-    setVolume: function (streamElement, volume) {
+    setVolume (streamElement, volume) {
         if (!RTCBrowserType.isIExplorer()) {
             streamElement.volume = volume;
         }
      * @param streamElement HTML element to which the RTC stream is attached to.
      * @param autoPlay 'true' or 'false'
      */
-    setAutoPlay: function (streamElement, autoPlay) {
+    setAutoPlay (streamElement, autoPlay) {
         if (!RTCBrowserType.isIExplorer()) {
             streamElement.autoplay = autoPlay;
         }

modules/RTC/RTCUtils.js

                 constraints.video.facingMode = facingMode;
             }
             constraints.video.optional.push({
-                facingMode: facingMode
+                facingMode
             });
         }
 
             track: videoStream.getVideoTracks()[0],
             mediaType: MediaType.VIDEO,
             videoType: VideoType.CAMERA,
-            resolution: resolution
+            resolution
         });
     }
 
                 obtainDevices({
                     devices: options.devices,
                     streams: [],
-                    successCallback: successCallback,
+                    successCallback,
                     errorCallback: reject,
-                    deviceGUM: deviceGUM
+                    deviceGUM
                 });
             } else {
                 var hasDesktop = options.devices.indexOf('desktop') > -1;
                                     dsOptions,
                                     function (desktopStream) {
                                         successCallback({audioVideo: stream,
-                                            desktopStream: desktopStream});
+                                            desktopStream});
                                     }, function (error) {
                                         self.stopMediaStream(stream);
 

modules/RTC/TraceablePeerConnection.js

 };
 
 var getters = {
-    signalingState: function () {
+    signalingState () {
         return this.peerconnection.signalingState;
     },
-    iceConnectionState: function () {
+    iceConnectionState () {
         return this.peerconnection.iceConnectionState;
     },
-    localDescription:  function() {
+    localDescription() {
         var desc = this.peerconnection.localDescription;
 
         this.trace('getLocalDescription::preTransform', dumpSDP(desc));
         }
         return desc;
     },
-    remoteDescription:  function() {
+    remoteDescription() {
         var desc = this.peerconnection.remoteDescription;
         this.trace('getRemoteDescription::preTransform', dumpSDP(desc));
 

modules/statistics/AnalyticsAdapter.js

      */
     sendEvent(action, data = {}) {
         this.eventCache.push({
-            action: action,
-            data: data
+            action,
+            data
         });
     }
 

modules/statistics/CallStats.js

     } else {
         CallStats.reportsQueue.push({
                 type: reportType.EVENT,
-                data: {event: event, eventData: eventData}
+                data: {event, eventData}
             });
         CallStats._checkInitialize();
     }
     } else {
         CallStats.reportsQueue.push({
             type: reportType.ERROR,
-            data: { type: type, error: e, pc: pc}
+            data: { type, error: e, pc}
         });
         CallStats._checkInitialize();
     }

modules/statistics/RTPStatsCollector.js

                         t.ip == ip && t.type == type && t.localip == localip
                     );})) {
                 conferenceStatsTransport.push(
-                    {ip: ip, type: type, localip: localip});
+                    {ip, type, localip});
             }
             continue;
         }
         ssrcStats.setLoss({
             packetsTotal: packetsDiff + packetsLostDiff,
             packetsLost: packetsLostDiff,
-            isDownloadStream: isDownloadStream
+            isDownloadStream
         });
 
         var bytesReceivedNow = getNonNegativeStat(now, 'bytesReceived');

modules/statistics/statistics.js

     if(this.callstats)
         this.callstats.sendFeedback(overall, detailed);
     Statistics.analytics.sendEvent("feedback.rating",
-        {value: overall, detailed: detailed});
+        {value: overall, detailed});
 };
 
 Statistics.LOCAL_JID = require("../../service/statistics/constants").LOCAL_JID;

modules/transcription/transcriberHolder.js

 var transcriberHolder = {
     transcribers : [],
 
-    add : function(transcriber){
+    add(transcriber){
         transcriberHolder.transcribers.push(transcriber);
     }
 };

modules/util/AuthUtil.js

      * <tt>null</tt> if 'urlPattern' is not a string and the URL can not be
      * constructed.
      */
-    getTokenAuthUrl: function (urlPattern, roomName, roleUpgrade) {
+    getTokenAuthUrl (urlPattern, roomName, roleUpgrade) {
         var url = urlPattern;
         if (typeof url !== "string") {
             return null;

modules/util/GlobalOnErrorHandler.js

      * Adds new error handlers.
      * @param handler the new handler.
      */
-    addHandler: function (handler) {
+    addHandler (handler) {
         handlers.push(handler);
     },
     /**
      * Calls the global error handler if there is one.
      * @param error the error to pass to the error handler
      */
-    callErrorHandler: function (error) {
+    callErrorHandler (error) {
         var errHandler = window.onerror;
         if(!errHandler)
             return;
      * Calls the global rejection handler if there is one.
      * @param error the error to pass to the rejection handler.
      */
-    callUnhandledRejectionHandler: function (error) {
+    callUnhandledRejectionHandler (error) {
         var errHandler = window.onunhandledrejection;
         if(!errHandler)
             return;

modules/util/RandomUtil.js

      * Returns a random hex digit.
      * @returns {*}
      */
-    randomHexDigit: function() {
+    randomHexDigit() {
         return randomElement(HEX_DIGITS);
     },
     /**
      * Returns a random string of hex digits with length 'len'.
      * @param len the length.
      */
-    randomHexString: function (len) {
+    randomHexString (len) {
         var ret = '';
         while (len--) {
             ret += this.randomHexDigit();
         }
         return ret;
     },
-    randomElement: randomElement,
-    randomAlphanumStr: randomAlphanumStr,
-    randomInt: randomInt
+    randomElement,
+    randomAlphanumStr,
+    randomInt
 };
 
 module.exports = RandomUtil;

modules/util/ScriptUtil.js

      * @param loadCallback on load callback function
      * @param errorCallback callback to be called on error loading the script
      */
-    loadScript: function (src, async, prepend, relativeURL,
+    loadScript (src, async, prepend, relativeURL,
                           loadCallback, errorCallback) {
         var d = document;
         var tagName = 'script';

modules/util/UsernameGenerator.js

 }
 
 module.exports = {
-  generateUsername: generateUsername
+  generateUsername
 };

modules/version/ComponentsVersions.js

             log.push({
                 id: "component_version",
                 component: componentName,
-                version: version});
+                version});
         }
     }.bind(this));
 

modules/xmpp/ChatRoom.js

 const logger = getLogger(__filename);
 
 var parser = {
-    packet2JSON: function (packet, nodes) {
+    packet2JSON (packet, nodes) {
         var self = this;
         $(packet).children().each(function () {
             var tagName = $(this).prop("tagName");
             const node = {
-                tagName: tagName
+                tagName
             };
             node.attributes = {};
             $($(this)[0].attributes).each(function( index, attr ) {
             self.packet2JSON($(this), node.children);
         });
     },
-    json2packet: function (nodes, packet) {
+    json2packet (nodes, packet) {
         for(let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
             if(!node || node === null){
             return;
         }
 
-        var pres = $pres({to: to });
+        var 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"
             {to: this.focusMucJid, type: 'set'})
             .c('mute', {
                 xmlns: 'http://jitsi.org/jitmeet/audio',
-                jid: jid
+                jid
             })
             .t(mute.toString())
             .up();

modules/xmpp/RtxModifier.js

                 videoMLine,
                 {
                     id: ssrc,
-                    cname: cname,
-                    msid: msid
+                    cname,
+                    msid
                 },
                 correspondingRtxSsrc);
         }

modules/xmpp/SDP.js

         tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc:');
         var mid = SDPUtil.parse_mid(SDPUtil.find_line(self.media[mediaindex], 'a=mid:'));
         var media = {
-            mediaindex: mediaindex,
-            mid: mid,
+            mediaindex,
+            mid,
             ssrcs: {},
             ssrcGroups: []
         };
             var ssrcs = line.substr(14 + semantics.length).split(' ');
             if (ssrcs.length) {
                 media.ssrcGroups.push({
-                    semantics: semantics,
-                    ssrcs: ssrcs
+                    semantics,
+                    ssrcs
                 });
             }
         });
         for (i = 0; i < lines.length; i++) {
             tmp = lines[i].split(' ');
             var semantics = tmp.shift().substr(8);
-            elem.c('group', {xmlns: 'urn:xmpp:jingle:apps:grouping:0', semantics:semantics});
+            elem.c('group', {xmlns: 'urn:xmpp:jingle:apps:grouping:0', semantics});
             for (j = 0; j < tmp.length; j++) {
                 elem.c('content', {name: tmp[j]}).up();
             }
                 {xmlns: 'urn:xmpp:jingle:apps:rtp:1',
                     media: mline.media });
             if (ssrc) {
-                elem.attrs({ssrc: ssrc});
+                elem.attrs({ssrc});
             }
             for (j = 0; j < mline.fmt.length; j++) {
                 rtpmap = SDPUtil.find_line(this.media[i], 'a=rtpmap:' + mline.fmt[j]);
 
             if (ssrc) {
                 // new style mapping
-                elem.c('source', { ssrc: ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+                elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                 // FIXME: group by ssrc and support multiple different ssrcs
                 var ssrclines = SDPUtil.find_lines(this.media[i], 'a=ssrc:');
                 if(ssrclines.length > 0) {
                         if (linessrc != ssrc) {
                             elem.up();
                             ssrc = linessrc;
-                            elem.c('source', { ssrc: ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+                            elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                         }
                         var kv = line.substr(idx + 1);
                         elem.c('parameter');
                     });
                 } else {
                     elem.up();
-                    elem.c('source', { ssrc: ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+                    elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                     elem.c('parameter');
                     elem.attrs({name: "cname", value:Math.random().toString(36).substring(7)});
                     elem.up();
                     var semantics = line.substr(0, idx).substr(13);
                     var ssrcs = line.substr(14 + semantics.length).split(' ');
                     if (ssrcs.length) {
-                        elem.c('ssrc-group', { semantics: semantics, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+                        elem.c('ssrc-group', { semantics, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                         ssrcs.forEach(function(ssrc) {
-                            elem.c('source', { ssrc: ssrc })
+                            elem.c('source', { ssrc })
                                 .up();
                         });
                         elem.up();

modules/xmpp/SDPDiffer.js

                     var nv = kv.split(':', 2);
                     var name = nv[0];
                     var value = SDPUtil.filter_special_chars(nv[1]);
-                    modify.attrs({ name: name });
-                    modify.attrs({ value: value });
+                    modify.attrs({ name });
+                    modify.attrs({ value });
                 }
                 modify.up(); // end of parameter
             });
                 });
 
                 ssrcGroup.ssrcs.forEach(function (ssrc) {
-                    modify.c('source', { ssrc: ssrc })
+                    modify.c('source', { ssrc })
                         .up(); // end of source
                 });
                 modify.up(); // end of ssrc-group

modules/xmpp/SDPUtil.js

 var RTCBrowserType = require("../RTC/RTCBrowserType");
 
 var SDPUtil = {
-    filter_special_chars: function (text) {
+    filter_special_chars (text) {
         // XXX Neither one of the falsy values (e.g. null, undefined, false,
         // "", etc.) "contain" special chars.
         return text ? text.replace(/[\\\/\{,\}\+]/g, "") : text;
     },
-    iceparams: function (mediadesc, sessiondesc) {
+    iceparams (mediadesc, sessiondesc) {
         var data = null;
         var ufrag, pwd;
         if ((ufrag = SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc))
         }
         return data;
     },
-    parse_iceufrag: function (line) {
+    parse_iceufrag (line) {
         return line.substring(12);
     },
-    build_iceufrag: function (frag) {
+    build_iceufrag (frag) {
         return 'a=ice-ufrag:' + frag;
     },
-    parse_icepwd: function (line) {
+    parse_icepwd (line) {
         return line.substring(10);
     },
-    build_icepwd: function (pwd) {
+    build_icepwd (pwd) {
         return 'a=ice-pwd:' + pwd;
     },
-    parse_mid: function (line) {
+    parse_mid (line) {
         return line.substring(6);
     },
-    parse_mline: function (line) {
+    parse_mline (line) {
         var parts = line.substring(2).split(' '),
             data = {};
         data.media = parts.shift();
         data.fmt = parts;
         return data;
     },
-    build_mline: function (mline) {
+    build_mline (mline) {
         return 'm=' + mline.media + ' ' + mline.port + ' ' + mline.proto + ' ' + mline.fmt.join(' ');
     },
-    parse_rtpmap: function (line) {
+    parse_rtpmap (line) {
         var parts = line.substring(9).split(' '),
             data = {};
         data.id = parts.shift();
      * @param line eg. "a=sctpmap:5000 webrtc-datachannel"
      * @returns [SCTP port number, protocol, streams]
      */
-    parse_sctpmap: function (line)
+    parse_sctpmap (line)
     {
         var parts = line.substring(10).split(' ');
         var sctpPort = parts[0];
         var streamCount = parts.length > 2 ? parts[2] : null;
         return [sctpPort, protocol, streamCount];// SCTP port
     },
-    build_rtpmap: function (el) {
+    build_rtpmap (el) {
         var line = 'a=rtpmap:' + el.getAttribute('id') + ' ' + el.getAttribute('name') + '/' + el.getAttribute('clockrate');
         if (el.getAttribute('channels') && el.getAttribute('channels') != '1') {
             line += '/' + el.getAttribute('channels');
         }
         return line;
     },
-    parse_crypto: function (line) {
+    parse_crypto (line) {
         var parts = line.substring(9).split(' '),
             data = {};
         data.tag = parts.shift();
         }
         return data;
     },
-    parse_fingerprint: function (line) { // RFC 4572
+    parse_fingerprint (line) { // RFC 4572
         var parts = line.substring(14).split(' '),
             data = {};
         data.hash = parts.shift();
         // TODO assert that fingerprint satisfies 2UHEX *(":" 2UHEX) ?
         return data;
     },
-    parse_fmtp: function (line) {
+    parse_fmtp (line) {
         var parts = line.split(' '),
             i, key, value,
             data = [];
             }
             value = parts[i].split('=')[1];
             if (key && value) {
-                data.push({name: key, value: value});
+                data.push({name: key, value});
             } else if (key) {
                 // rfc 4733 (DTMF) style stuff
                 data.push({name: '', value: key});
         }
         return data;
     },
-    parse_icecandidate: function (line) {
+    parse_icecandidate (line) {
         var candidate = {},
             elems = line.split(' ');
         candidate.foundation = elems[0].substring(12);
         candidate.id = Math.random().toString(36).substr(2, 10); // not applicable to SDP -- FIXME: should be unique, not just random
         return candidate;
     },
-    build_icecandidate: function (cand) {
+    build_icecandidate (cand) {
         var line = ['a=candidate:' + cand.foundation, cand.component, cand.protocol, cand.priority, cand.ip, cand.port, 'typ', cand.type].join(' ');
         line += ' ';
         switch (cand.type) {
         line += cand.hasOwnAttribute('generation') ? cand.generation : '0';
         return line;
     },
-    parse_ssrc: function (desc) {
+    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
         }
         return data;
     },
-    parse_rtcpfb: function (line) {
+    parse_rtcpfb (line) {
         var parts = line.substr(10).split(' ');
         var data = {};
         data.pt = parts.shift();
         data.params = parts;
         return data;
     },
-    parse_extmap: function (line) {
+    parse_extmap (line) {
         var parts = line.substr(9).split(' ');
         var data = {};
         data.value = parts.shift();
         data.params = parts;
         return data;
     },
-    find_line: function (haystack, needle, sessionpart) {
+    find_line (haystack, needle, sessionpart) {
         var lines = haystack.split('\r\n');
         for (var i = 0; i < lines.length; i++) {
             if (lines[i].substring(0, needle.length) == needle) {
         }
         return false;
     },
-    find_lines: function (haystack, needle, sessionpart) {
+    find_lines (haystack, needle, sessionpart) {
         var lines = haystack.split('\r\n'),
             needles = [];
         for (var i = 0; i < lines.length; i++) {
         }
         return needles;
     },
-    candidateToJingle: function (line) {
+    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=.../>
         if (line.indexOf('candidate:') === 0) {
         candidate.id = Math.random().toString(36).substr(2, 10); // not applicable to SDP -- FIXME: should be unique, not just random
         return candidate;
     },
-    candidateFromJingle: function (cand) {
+    candidateFromJingle (cand) {
         var line = 'a=candidate:';
         line += cand.getAttribute('foundation');
         line += ' ';
      * @param {object} mLine object as parsed from transform.parse
      * @return {number} the primary video ssrc from the given m line
      */
-    parsePrimaryVideoSsrc: function(videoMLine) {
+    parsePrimaryVideoSsrc(videoMLine) {
         const numSsrcs = videoMLine.ssrcs
             .map(ssrcInfo => ssrcInfo.id)
             .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
      * Generate an ssrc
      * @returns {number} an ssrc
      */
-    generateSsrc: function() {
+    generateSsrc() {
         return RandomUtil.randomInt(1, 0xffffffff);
     },
 
      * @returns {string} the value corresponding to the given ssrc
      *  and attributeName
      */
-    getSsrcAttribute: function (mLine, ssrc, attributeName) {
+    getSsrcAttribute (mLine, ssrc, attributeName) {
         for (let i = 0; i < mLine.ssrcs.length; ++i) {
             const ssrcLine = mLine.ssrcs[i];
             if (ssrcLine.id === ssrc &&
      * @returns {list<number>} a list of the ssrcs in the group
      *  parsed as numbers
      */
-    parseGroupSsrcs: function (ssrcGroup) {
+    parseGroupSsrcs (ssrcGroup) {
         return ssrcGroup
             .ssrcs
             .split(" ")
      * @param {string} type the type of the desired mline (e.g. "video")
      * @returns {object} a media object
      */
-    getMedia: function (sdp, type) {
+    getMedia (sdp, type) {
         return sdp.media.find(m => m.type === type);
     },
     /**
      *  an sdp as parsed by transform.parse
      * @param {string} the name of the preferred codec
      */
-    preferVideoCodec: function(videoMLine, codecName) {
+    preferVideoCodec(videoMLine, codecName) {
         let payloadType = null;
         for (let i = 0; i < videoMLine.rtp.length; ++i) {
           const rtp = videoMLine.rtp[i];

modules/xmpp/recording.js

     elem.c('conference', {
         xmlns: 'http://jitsi.org/protocol/colibri'
     });
-    elem.c('recording', {state: state, token: options.token});
+    elem.c('recording', {state, token: options.token});
 
     var self = this;
     this.connection.sendIQ(elem,

modules/xmpp/strophe.rayo.js

             });
             req.c('dial', {
                 xmlns: RAYO_XMLNS,
-                to: to,
-                from: from
+                to,
+                from
             });
             req.c('header', {
                 name: 'JvbRoomName',

modules/xmpp/xmpp.js

 
     connect (jid, password) {
         this.connectParams = {
-            jid: jid,
-            password: password
+            jid,
+            password
         };
         if (!jid) {
             let configDomain

webpack.config.js

         libraryTarget: 'umd',
         sourceMapFilename: '[name].' + (minimize ? 'min' : 'js') + '.map'
     },
-    plugins: plugins
+    plugins
 };