@monterosa/sdk-lvis 0.18.8 → 0.18.10

package/dist/index.esm2017.js

@@ -13,7 +13,7 @@ import Cookie from 'js-cookie';
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
 
-var version = "0.18.8";
+var version = "0.18.10";
 
 var LViSDate = new Emitter();
 LViSDate.trigger = LViSDate.emit;
@@ -24,11 +24,8 @@ LViSDate.ON_NEXT = 'next';
 var serverTimestamp;
 var lastTickTimestamp;
 var tickTimeoutId = null;
-
 var getCurrentTimestamp = () => Date.now() / 1000;
-
 var getMiddleTimestamp = timestamp => Math.floor(timestamp) + 0.5;
-
 var tick = () => {
   clearTimeout(tickTimeoutId);
   var currentTimestamp = getCurrentTimestamp();
@@ -40,14 +37,11 @@ var tick = () => {
   tickTimeoutId = setTimeout(tick, delay);
   LViSDate.trigger(LViSDate.ON_TICK, serverTimestamp);
 };
-
 LViSDate.setTime = time => {
   lastTickTimestamp = getCurrentTimestamp();
   serverTimestamp = getMiddleTimestamp(time);
 };
-
 LViSDate.now = () => Math.floor(serverTimestamp);
-
 LViSDate.setTime(getCurrentTimestamp());
 tick();
 
@@ -61,127 +55,102 @@ var Sync = (() => {
   var defaultDelay;
   var maxDelay;
   var Event;
-
   var setDelay = (value, force) => {
     var max = Number.MAX_SAFE_INTEGER || 9007199254740991;
-
     if (value > max) {
       console.warn("User delay can't be greater than ".concat(max, " seconds"));
       return;
     }
-
     if (value < 0) {
       value = 0;
     }
-
     if (value > maxDelay) {
       value = maxDelay;
     }
-
     if (force || value !== delay) {
       delay = value;
       self.trigger(self.ON_DELAY_CHANGE, delay);
     }
   };
-
   self._resetSettings = () => {
     delay = null;
     defaultDelay = 0;
     maxDelay = Number.MAX_SAFE_INTEGER || 9007199254740991;
   };
-
   self.setMaxDelay = value => {
     value = parseInt(value, 10);
-
     if (value >= 0) {
       maxDelay = value;
     }
   };
-
   self.setDefaultDelay = value => {
     value = parseInt(value, 10);
-
     if (value > maxDelay) {
       defaultDelay = maxDelay;
     } else if (value > 0 && value <= maxDelay) {
       defaultDelay = value;
     }
   };
-
   self.setDelay = function () {
     var value;
-
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     var force = [...args].pop();
     force = typeof force === 'boolean' ? force : false;
-
     switch (args[0].constructor) {
       // (<LViS.Event> event, <Integer> timecode, [<Boolen> force = true]);
       case Event:
         {
           var event = args[0],
-              timecode = args[1];
+            timecode = args[1];
           value = LViSDate.now() - event.getOriginalStartAt() - timecode;
           break;
         }
-      // (<Date> time, [<Boolen> force = true]);
 
+      // (<Date> time, [<Boolen> force = true]);
       case Date:
         {
           var time = args[0];
           value = LViSDate.now() - Math.floor(time.getTime() / 1000);
           break;
         }
-      // (<Integer> delay, [<Boolen> force = true]);
 
+      // (<Integer> delay, [<Boolen> force = true]);
       case Number:
         {
           value = args[0];
-
           if (parseInt(value, 10) !== value) {
             console.warn('User delay must be an integer');
             return;
           }
-
           break;
         }
-
       default:
         console.warn('Unknown interface of setDelay() method');
         return;
     }
-
     setDelay(value, force);
   };
-
   self.getMaxDelay = () => maxDelay;
-
   self.getDelay = () => {
     if (delay !== null) {
       return delay;
     }
-
     return defaultDelay;
   };
-
   self._resetSettings();
-
   self.init = config => {
     // used to avoid cycle dependency:
     // Event -> ConnectionAdaptor -> Sync -> Event
     Event = config.Event;
   };
-
   return self;
 })();
 
 /* eslint @typescript-eslint/indent: "off" */
 var regularQueue = [];
 var priorityQueue = [];
-
 var add = queue => function (func) {
   var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   return queue.push({
@@ -189,13 +158,11 @@ var add = queue => function (func) {
     context
   });
 };
-
 var execute = function execute() {
   var queue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return () => {
     var item;
     var total = queue.length;
-
     while (total > 0) {
       item = queue.shift();
       item.func.apply(item.context);
@@ -203,20 +170,16 @@ var execute = function execute() {
     }
   };
 };
-
 var force = () => {
   executePriority();
   executeRegular();
 };
-
 var handleDateTick = () => {
   force();
 };
-
 var handleDateNext = func => {
   nextRegular(func);
 };
-
 var nextRegular = add(regularQueue);
 var nextPriority = add(priorityQueue);
 var executeRegular = execute(regularQueue);
@@ -235,10 +198,12 @@ var ConnectionAdaptor = (() => {
   /*
    * Link to the current scope
    */
+
   var self = new Emitter();
   self.trigger = self.emit;
   self.bind = self.on;
   self.unbind = self.off;
+
   /*
    * Constants
    */
@@ -246,6 +211,7 @@ var ConnectionAdaptor = (() => {
   self.ON_EOC = Enmasse.ON_EOC;
   self.ON_MESSAGE = Enmasse.ON_MESSAGE;
   self.ON_SETTINGS = 'settings';
+
   /*
    * Private variable
    */
@@ -253,87 +219,71 @@ var ConnectionAdaptor = (() => {
   var queue = [];
   var EOCs = {};
   var processIsInThePriorityQueue = false;
-
   var handleMessage = message => {
     deduplicate(message);
     queue.push(message);
     Run.nextPriority(() => process());
     Run.force();
   };
-
   var handleDelayChange = () => {
     clearQueue();
   };
-
   var handleState = state => {
     switch (state) {
       case Enmasse.STATE_DISCONNECTED:
         clearEOCs();
         break;
-
       case Enmasse.STATE_CONNECTED:
         break;
-
       case Enmasse.STATE_CONNECTING:
         break;
     }
   };
-
   var handleEOC = channel => {
     EOCs[channel] = true;
     self.trigger(self.ON_EOC, channel);
     Run.nextPriority(() => process());
     Run.force();
   };
-
   var deduplicate = message => {
     if (message.klass !== 'create') {
       return;
     }
-
     var id;
-
     try {
       id = JSON.parse(message.body[0]).id;
     } catch (e) {
       return;
     }
-
     var itemId = null;
-
     for (var idx = 0; idx < queue.length; idx++) {
       try {
         itemId = JSON.parse(queue[idx].body[0]).id;
       } catch (e) {
         continue;
       }
-
       if (itemId === id) {
         queue.splice(idx, 1);
         break;
       }
     }
   };
-
   var process = () => {
     var idx = 0;
     var message;
-
     while (idx < queue.length) {
       if (canAdapt(queue[idx])) {
         var _queue$splice = queue.splice(idx, 1);
-
         var _queue$splice2 = _slicedToArray(_queue$splice, 1);
-
         message = _queue$splice2[0];
         adaptMessage(message);
         self.trigger(self.ON_MESSAGE, message);
       } else {
         idx++;
       }
-    } // if there are still left message in queue
-
+    }
 
+    // if there are still left message in queue
     if (queue.length > 0 && !processIsInThePriorityQueue) {
       processIsInThePriorityQueue = true;
       Run.nextPriority(() => {
@@ -342,74 +292,56 @@ var ConnectionAdaptor = (() => {
       });
     }
   };
-
   var canAdapt = message => {
     var checker = (() => {
       switch (message.klass) {
         case 'create':
           return canAdaptCreate;
-
         case 'reveal':
           return canAdaptReveal;
-
         case 'revoke':
           return canAdaptRevoke;
-
         case 'stop':
           return canAdaptStop;
-
         case 'p':
           return canAdaptPoll;
-
         case 'subscounter':
           return canAdaptSubsCounter;
-
         default:
           return canAdaptOther;
       }
     })();
-
     return checker(message);
   };
-
   var canAdaptCreate = message => {
     var data;
-
     try {
       data = JSON.parse(message.body[0]);
     } catch (e) {
       return false;
     }
-
     return canAdaptGeneric(message.channel, data.published_at);
   };
-
   var canAdaptReveal = message => canAdaptGeneric(message.channel, parseInt(message.body[2], 10));
-
   var canAdaptRevoke = message => {
     var data;
-
     try {
       data = JSON.parse(message.body[0]);
     } catch (e) {
       return false;
     }
-
     return canAdaptGeneric(message.channel, data.sent_at);
   };
-
   var canAdaptStop = message => canAdaptGeneric(message.channel, parseInt(message.body[1], 10));
-
   var canAdaptPoll = message => canAdaptGeneric(message.channel, parseInt(message.body[1], 10));
-
   var canAdaptSubsCounter = message => canAdaptGeneric(message.channel, parseInt(message.sent_at, 10));
-
   var canAdaptOther = () => true;
-
   var canAdaptGeneric = (channel, publishAt) => {
     var now = LViSDate.now();
     var hasEOC = EOCs[channel] !== undefined;
-    var publishAtDelayed = publishAt + Sync.getDelay(); // Can publish whether:
+    var publishAtDelayed = publishAt + Sync.getDelay();
+
+    // Can publish whether:
     // a. publishedAt is in the past,
     // b. publishedAt is now, but only if we already received EOC. If we
     // have not yet received EOC then there is a risk that we will receive
@@ -419,186 +351,159 @@ var ConnectionAdaptor = (() => {
     // element into history rather than trigger ON_PUBLISHED. With this
     // check we guarantee that if create and EOC arrive at the same second
     // we do not trigger elements until we handled EOC.
-
     return publishAtDelayed < now || publishAtDelayed === now && hasEOC;
   };
-
   var adaptMessage = message => {
     var adaptor = (() => {
       switch (message.klass) {
         case 'snapshot':
           return adaptSnapshot;
-
         case 'listings':
           return adaptListings;
-
         case 'create':
           return adaptCreate;
-
         case 'reveal':
           return adaptReveal;
-
         case 'revoke':
           return adaptRevoke;
-
         case 'stop':
           return adaptStop;
-
         case 'p':
           return adaptPoll;
-
         case 'subscounter':
           return adaptSubsCounter;
-
         default:
           return adaptOther;
       }
     })();
-
     adaptor(message);
   };
-
   var adaptSnapshot = message => {
     // console.log('ConnectionAdaptor::adaptSnapshot', message);
-    var snapshot;
 
+    var snapshot;
     try {
       snapshot = JSON.parse(message.body[0]);
-    } catch (e) {// console.error('ConnectionAdaptor: Unable to parse listings data');
+    } catch (e) {
+      // console.error('ConnectionAdaptor: Unable to parse listings data');
     }
-
     adaptSnapshotData(snapshot);
     message.body[0] = JSON.stringify(snapshot);
   };
-
   var adaptSnapshotData = snapshot => {
     snapshot.published_at += Sync.getDelay();
     snapshot.published_at_iso = new Date(snapshot.published_at * 1000).toISOString();
-
     var adapter = (() => {
       switch (snapshot.type) {
         case 'prediction':
           return adaptPredictionSnapshot;
-
         default:
           return adaptOtherSnapshot;
       }
     })();
-
     adapter(snapshot);
   };
-
   var adaptPredictionSnapshot = snapshot => {
     var data = snapshot.data;
     var delay = Sync.getDelay();
     data.start_at += delay;
     data.start_at_iso = new Date(data.start_at * 1000).toISOString();
-
     if (data.stop_at) {
       data.stop_at += delay;
       data.stop_at_iso = new Date(data.stop_at * 1000).toISOString();
     }
-
     if (data.reveal_answer_at) {
       data.reveal_answer_at += delay;
       data.reveal_answer_at_iso = new Date(data.reveal_answer_at * 1000).toISOString();
     }
   };
-
-  var adaptOtherSnapshot = () => {// console.log('ConnectionAdaptor::adaptOtherSnapshot', snapshot);
+  var adaptOtherSnapshot = () => {
+    // console.log('ConnectionAdaptor::adaptOtherSnapshot', snapshot);
   };
-
   var adaptListings = message => {
     // console.log('ConnectionAdaptor::adaptListings');
-    var listings;
 
+    var listings;
     try {
       listings = JSON.parse(message.body[0]);
-    } catch (e) {// console.error('ConnectionAdaptor: Unable to parse listings data');
+    } catch (e) {
+      // console.error('ConnectionAdaptor: Unable to parse listings data');
     }
-
     Sync.setMaxDelay(listings.project.audio_sync_max_delay);
     Sync.setDefaultDelay(listings.project.audio_sync_default_delay);
-
     for (var uuid in listings.events) {
       if ({}.hasOwnProperty.call(listings.events, uuid)) {
         adaptEvent(listings.events[uuid]);
       }
     }
-
     message.body[0] = JSON.stringify(listings);
   };
-
   var adaptEvent = event => {
     var delay = Sync.getDelay();
     event.start_at += delay;
     event.start_at_iso = new Date(event.start_at * 1000).toISOString();
     event.end_at += delay;
-    event.end_at_iso = new Date(event.end_at * 1000).toISOString(); // store delay
+    event.end_at_iso = new Date(event.end_at * 1000).toISOString();
 
+    // store delay
     event.__delay = delay;
   };
-
   var adaptCreate = message => {
     // console.log('ConnectionAdaptor::adaptCreate', message);
-    var data;
 
+    var data;
     try {
       data = JSON.parse(message.body[0]);
-    } catch (e) {// console.error('ConnectionAdaptor: Unable to parse create data');
+    } catch (e) {
+      // console.error('ConnectionAdaptor: Unable to parse create data');
     }
-
     data.published_at += Sync.getDelay();
     data.published_at_iso = new Date(data.published_at * 1000).toISOString();
     message.body[0] = JSON.stringify(data);
   };
-
   var adaptPoll = message => {
     // console.log('ConnectionAdaptor::adaptPoll', message);
+
     message.body[1] = parseInt(message.body[1], 10) + Sync.getDelay();
   };
-
   var adaptStop = message => {
     // console.log('ConnectionAdaptor::adaptStop', message);
+
     message.body[1] = parseInt(message.body[1], 10) + Sync.getDelay();
   };
-
   var adaptReveal = message => {
     // console.log('ConnectionAdaptor::adaptReveal', message);
+
     message.body[2] = parseInt(message.body[2], 10) + Sync.getDelay();
   };
-
   var adaptRevoke = message => {
     // console.log('ConnectionAdaptor::adaptRevoke', message);
-    var data;
 
+    var data;
     try {
       data = JSON.parse(message.body[0]);
-    } catch (e) {// console.error('ConnectionAdaptor: Unable to parse revoke data');
+    } catch (e) {
+      // console.error('ConnectionAdaptor: Unable to parse revoke data');
     }
-
     data.sent_at += Sync.getDelay();
     data.sent_at_iso = new Date(data.sent_at * 1000).toISOString();
     message.body[0] = JSON.stringify(data);
   };
-
   var adaptSubsCounter = message => {
     try {
       var data = JSON.parse(message.body[0]);
       data.next_update_at += Sync.getDelay();
       message.body[0] = JSON.stringify(data);
-    } catch (e) {// why do we fail silently?
+    } catch (e) {
+      // why do we fail silently?
     }
   };
-
   var adaptOther = () => 0;
-
   var clearQueue = () => {
     while (queue.length) {
       queue.pop();
     }
   };
-
   var clearEOCs = () => {
     for (var eoc in EOCs) {
       if ({}.hasOwnProperty.call(EOCs, eoc)) {
@@ -606,11 +511,9 @@ var ConnectionAdaptor = (() => {
       }
     }
   };
-
   self.subscribe = channel => {
     Enmasse.subscribe(channel);
   };
-
   self.unsubscribe = channel => {
     queue.forEach((message, idx) => {
       if (message.channel === channel) {
@@ -620,11 +523,8 @@ var ConnectionAdaptor = (() => {
     delete EOCs[channel];
     Enmasse.unsubscribe(channel);
   };
-
   self.adaptSnapshotData = message => adaptSnapshotData(message);
-
   self.adaptEvent = event => adaptEvent(event);
-
   Enmasse.bind(Enmasse.ON_MESSAGE, handleMessage);
   Enmasse.bind(Enmasse.ON_STATE, handleState);
   Enmasse.bind(Enmasse.ON_EOC, handleEOC);
@@ -636,17 +536,13 @@ class Base extends Emitter {
   get(id) {
     return this.instances[id] || false;
   }
-
   create() {}
-
   createSnapshot() {}
-
   revoke(id) {
     if ({}.hasOwnProperty.call(this.instances, id)) {
       delete this.instances[id];
     }
   }
-
   destroyInstances() {
     // console.log("BaseFactory::destroyInstances", this.instances);
     for (var id in this.instances) {
@@ -656,7 +552,6 @@ class Base extends Emitter {
       }
     }
   }
-
   constructor() {
     super();
     this.instances = {};
@@ -664,63 +559,50 @@ class Base extends Emitter {
     this.bind = this.on;
     this.unbind = this.off;
   }
-
 }
 
 class FrameFactory extends Base {
   getByEnmasseId(enmasseId) {
     for (var _i = 0, _Object$values = Object.values(this.instances); _i < _Object$values.length; _i++) {
       var instance = _Object$values[_i];
-
       if (instance.getEnmasseId() === enmasseId) {
         return instance;
       }
     }
-
     return false;
   }
-
   setMessages() {}
-
   update(instance, data) {
     instance.update(data);
   }
-
 }
 
 class Entity extends Emitter {
   getId() {
     return this.id;
   }
-
   getEnmasseId() {
     return this.enmasseId;
   }
-
   getFullId() {
     return "".concat(this.id, ".").concat(this.enmasseId);
   }
-
   getPublishedAt() {
     return this.publishedAt;
   }
-
   getUpdatedAt() {
     return this.updatedAt;
   }
-
   finalize() {
     this.finalized.resolve();
   }
-
   update() {
     var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     this.updatedAt = config.updated_at - 0 || 0;
   }
-
-  destroy() {// console.log("Entity::destroy id=%s" + this.getId());
+  destroy() {
+    // console.log("Entity::destroy id=%s" + this.getId());
   }
-
   constructor() {
     var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     super(config);
@@ -733,14 +615,12 @@ class Entity extends Emitter {
     this.bind = this.on;
     this.unbind = this.off;
   }
-
 }
 
 /* global QUOTA_EXCEEDED_ERR */
 var globals = getGlobal();
 var StorageLocalDriver = (() => {
   var self = {};
-
   self.hasSupport = () => {
     try {
       return 'localStorage' in global && globals.localStorage !== null;
@@ -748,7 +628,6 @@ var StorageLocalDriver = (() => {
       return false;
     }
   };
-
   self.set = (name, value) => {
     try {
       globals.localStorage.setItem(name, value);
@@ -758,19 +637,14 @@ var StorageLocalDriver = (() => {
       }
     }
   };
-
   self.get = name => globals.localStorage.getItem(name);
-
   self.remove = name => globals.localStorage.removeItem(name);
-
   return self;
 })();
 var StorageCookieDriver = (() => {
   var self = {};
-
   self.hasSupport = () => {
     var probe = 'probe';
-
     try {
       self.set(probe, probe);
       var stored = self.get(probe);
@@ -780,31 +654,23 @@ var StorageCookieDriver = (() => {
       return false;
     }
   };
-
   self.set = (name, value, expires) => {
     var args = [name, value];
-
     if (typeof expires !== 'undefined') {
       args.push({
         expires
       });
     }
-
     return Cookie.set(...args);
   };
-
   self.get = name => {
     var value = Cookie.get(name);
-
     if (typeof value === 'undefined') {
       return null;
     }
-
     return value;
   };
-
   self.remove = name => Cookie.remove(name);
-
   return self;
 })();
 var Storage = (() => {
@@ -812,46 +678,35 @@ var Storage = (() => {
   var self = {};
   var driver = null;
   var prefix = 'lvis';
-
   for (var i = 0; i < DRIVERS.length; i++) {
     if (DRIVERS[i].hasSupport()) {
       driver = DRIVERS[i];
       break;
     }
   }
-
   var enabled = () => driver !== null;
-
   var toStoredName = name => [prefix, name].join('-');
-
   self.setPrefix = newPrefix => {
     prefix = newPrefix;
   };
-
   self.set = (name, value, expires) => {
     if (enabled()) {
       return driver.set(toStoredName(name), value, expires);
     }
-
     return undefined;
   };
-
   self.get = name => {
     if (enabled()) {
       return driver.get(toStoredName(name));
     }
-
     return undefined;
   };
-
   self.remove = name => {
     if (enabled()) {
       return driver.remove(toStoredName(name));
     }
-
     return undefined;
   };
-
   return self;
 })();
 
@@ -868,9 +723,7 @@ var Project = (() => {
   self.unbind = self.off;
   self.ON_SUBS_COUNT = 'subs_count';
   self.ON_SUBS_COUNT_MISSING = 'subs_count_missing';
-
   var getDefaultLanguage = () => data.locales.find(locale => !!locale.default);
-
   var loadAppSettings = () => {
     var url = "".concat(host, "/projects/").concat(uuid.substr(0, 2), "/").concat(uuid, "/settings.json");
     var dfd = new Deferred();
@@ -880,7 +733,6 @@ var Project = (() => {
       var settingsData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       var status = resp.statusCode;
       var isSuccess = status >= 200 && status <= 300 || status === 0 || status === '';
-
       if (isSuccess) {
         settings = settingsData;
         dfd.resolve();
@@ -890,21 +742,17 @@ var Project = (() => {
     });
     return dfd.promise();
   };
-
   var hasLanguage = language => data.locales.some(_ref => {
     var key = _ref.key;
     return key === language;
   });
-
   var handleSubsMissing = () => {
     self.trigger(self.ON_SUBS_COUNT_MISSING);
   };
-
   var handleSubsCount = message => {
     if (message.klass !== 'subscounter') {
       return;
     }
-
     try {
       var subsData = JSON.parse(message.body[0]);
       var nextSubsUpdate = subsData.next_update_at;
@@ -915,22 +763,21 @@ var Project = (() => {
       console.warn("Couldn't parse subscounter message.");
     }
   };
-
   self.setData = d => {
     data = d || {};
     Storage.setPrefix("lvis-".concat(uuid));
-    var storedLanguage = Storage.get('lang'); // trying to set stored language
+    var storedLanguage = Storage.get('lang');
 
+    // trying to set stored language
     if (storedLanguage) {
       self.setCurrentLanguage(storedLanguage);
-    } // if current is not set yet using default language
-
+    }
 
+    // if current is not set yet using default language
     if (currentLanguage === null) {
       currentLanguage = getDefaultLanguage().key;
     }
   };
-
   self.setCurrentLanguage = language => {
     if (hasLanguage(language)) {
       currentLanguage = language;
@@ -939,57 +786,41 @@ var Project = (() => {
       console.warn("Attempt to set unknown language \"".concat(language, "\""));
     }
   };
-
   self.get = name => {
     if (typeof name === 'undefined') {
       // return full dataset if parameter name is not set
       return data;
     }
-
     if (typeof data[name] !== 'undefined') {
       // return value that matches passed parameter name in dataset
       return data[name];
     }
-
     return null;
   };
-
   self.getSettings = name => {
     var values = self.localise(settings);
-
     if (typeof name === 'undefined') {
       return values;
     }
-
     if (typeof values[name] !== 'undefined') {
       return values[name];
     }
-
     return null;
   };
-
   self.getUUID = () => uuid;
-
   self.getLanguages = () => self.get('locales');
-
   self.getCurrentLanguage = () => currentLanguage;
-
   self.getEmbedUrl = () => self.get('embed');
-
   self.isLocalisationSupported = () => self.get('is_localisation_supported');
-
   self.localise = value => {
     if ({}.hasOwnProperty.call(value, currentLanguage)) {
       return value[currentLanguage];
     }
-
     if ({}.hasOwnProperty.call(value, 'all')) {
       return value.all;
     }
-
     return value;
   };
-
   self.init = function () {
     var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     uuid = config.uuid;
@@ -997,7 +828,6 @@ var Project = (() => {
     ConnectionAdaptor.bind(ConnectionAdaptor.ON_MESSAGE, handleSubsCount);
     return loadAppSettings();
   };
-
   return self;
 })();
 
@@ -1005,85 +835,70 @@ class Frame extends Entity {
   getEnmasseId() {
     return this.enmasseId;
   }
-
   getDuration() {
     return this.duration;
   }
-
   getDurationLeft() {
     return this.durationLeft;
   }
-
   getType() {
     return this.type;
   }
-
   getContentType() {
     // should return basic type if custom type is null
     return this.contentType === null ? this.type : this.contentType;
   }
-
   getCustomFields(field) {
     var values = Project.localise(this.customFields);
-
     if (typeof field === 'undefined') {
       // return full set of custom fields if field name wasn't passed
       return values;
-    } // custom field was passed
-
+    }
 
+    // custom field was passed
     if (typeof values[field] !== 'undefined') {
       // return specific field if field exists in object
       return values[field];
-    } // otherwise return null
-
+    }
 
+    // otherwise return null
     return null;
   }
-
   hasFixedDuration() {
     return this.fixed;
   }
-
   setDuration(duration) {
     this.duration = parseInt(duration, 10);
   }
-
   setDurationLeft(duration) {
     this.durationLeft = parseInt(duration, 10);
   }
-
   abort(time) {
     this.aborted = true;
     this.setDuration(time - this.getPublishedAt());
     this.setDurationLeft(0);
   }
-
   updateDurationLeft() {
     if (this.aborted) {
       return;
     }
-
     var self = this;
     var endAt = this.publishedAt + this.duration;
     var now = LViSDate.now();
     var left = endAt - now;
     this.setDurationLeft(left);
-
     if (this.durationLeft > 0) {
       Run.nextPriority(() => self.updateDurationLeft());
     } else {
       this.durationLeft = 0;
     }
   }
-
   update() {
     var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     super.update(config);
     this.duration = config.duration - 0 || 0;
     this.customFields = config.custom_fields || {};
   }
-
   constructor() {
     var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     super(config);
@@ -1095,35 +910,30 @@ class Frame extends Entity {
     this.type = config.type;
     this.fixed = config.fixed;
     this.contentType = config.content_type || null;
-    this.customFields = config.custom_fields || {}; // calculate real duration left only for fixed frames
+    this.customFields = config.custom_fields || {};
 
+    // calculate real duration left only for fixed frames
     if (this.fixed) {
       this.updateDurationLeft();
     }
   }
-
 }
 
 class Poll extends Frame {
   getQuestion() {
     return Project.localise(this.question);
   }
-
   getOptions() {
     return Project.localise(this.options);
   }
-
   getResults() {
     if (!this.canReveal()) {
       return [];
     }
-
     return this.results;
   }
-
   getResultsPerSource(source) {
     var results = null;
-
     if (typeof source === 'undefined') {
       results = this.resultsPerSource;
     } else {
@@ -1133,104 +943,86 @@ class Poll extends Frame {
         }
       }
     }
-
     return results;
   }
-
   getState() {
     return this.state;
   }
-
   getUserVote() {
     return this.votedFor;
   }
-
   hasUserVoted() {
     return this.getUserVote() !== null;
   }
-
   hasResults() {
     return this.results !== null && this.canReveal();
   }
-
   canReveal() {
     return true;
   }
-
   isValidatedUserRequired() {
     return this.requiresValidatedUser;
   }
-
   vote() {
     var vote = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     var indices = Object.keys(vote);
     var options = this.getOptions();
     var nonexistantVotes = indices.filter(idx => typeof options[idx] === 'undefined');
-
     if (nonexistantVotes.length > 0) {
       console.warn("Can't vote for nonexistant %s (%s)", nonexistantVotes.length === 1 ? 'option' : 'options', nonexistantVotes.join(', '));
       return false;
     }
-
     this.storeVote(vote);
     this.trigger(Poll.ON_VOTE, vote);
     return true;
   }
-
   setState(state) {
     // do not fire state change if passed state is the same as it was
     if (state === undefined || state === this.state) {
       return;
     }
-
     this.state = state;
-    this.trigger(Poll.ON_STATE_CHANGE, state); // Order of messages from enmasse is not guaranteed.
+    this.trigger(Poll.ON_STATE_CHANGE, state);
+
+    // Order of messages from enmasse is not guaranteed.
     // Stop or reveal messages can be after feedback message.
     // If feedback message is received before user is able to see results are saved
     // and set resultsTriggerPostponed true.
     // When state(stop, reveal) allows reveal results and reveal results was postponed
     // action ON_RESULTS triggered.
-
     if (this.canReveal() && this.resultsTriggerPostponed) {
       this.resultsTriggerPostponed = false;
       this.trigger(Poll.ON_RESULTS);
     }
   }
-
   setResults(results) {
     // skip setting results if they weren't changed
     if (JSON.stringify(results) === JSON.stringify(this.rawResults)) {
       return;
     }
-
     this.rawResults = results;
     this.populateResults(results);
-
     if (this.hasResults()) {
       this.trigger(Poll.ON_RESULTS);
     } else {
       this.resultsTriggerPostponed = true;
     }
   }
-
   setResultsPerSource(results) {
     this.populateResultsPerSource(results);
   }
-
   isStarted() {
     return this.state === Poll.STATE_STARTED;
   }
-
   isClosed() {
     return this.state === Poll.STATE_CLOSED;
   }
-
   stop(time) {
     this.abort(time);
     this.setState(Poll.STATE_CLOSED);
-  } // TODO: Combine populateResults() and populateResultsFromSnapshot() methods
-
+  }
 
+  // TODO: Combine populateResults() and populateResultsFromSnapshot() methods
   populateResults(results) {
     var percentage = calculatePercentage(results);
     this.results = results.map((votes, idx) => ({
@@ -1238,7 +1030,6 @@ class Poll extends Frame {
       percentage: percentage[idx]
     }));
   }
-
   populateResultsPerSource(results) {
     this.resultsPerSource = results;
     this.resultsPerSource.forEach(source => {
@@ -1249,7 +1040,6 @@ class Poll extends Frame {
       }));
     });
   }
-
   storeVote(vote) {
     var name = "frame-".concat(this.getId());
     var value = JSON.stringify(vote);
@@ -1257,24 +1047,20 @@ class Poll extends Frame {
     this.votedFor = vote;
     Storage.set(name, value, expire);
   }
-
   restoreVote() {
     var name = "frame-".concat(this.getId());
-
     try {
       this.votedFor = JSON.parse(Storage.get(name));
     } catch (exception) {
       console.error('Unable to restore option user voted for', exception);
     }
   }
-
   update() {
     var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     super.update(config);
     this.question = config.data.question;
     this.options = config.data.options;
   }
-
   constructor(config) {
     super(config);
     this.question = config.data.question;
@@ -1288,92 +1074,74 @@ class Poll extends Frame {
     this.resultsTriggerPostponed = false;
     this.restoreVote();
   }
-
 }
-
 _defineProperty(Poll, "EXPIRE", 7 * 24 * 60 * 60);
-
 _defineProperty(Poll, "STATE_STARTED", 'started');
-
 _defineProperty(Poll, "STATE_CLOSED", 'stopped');
-
 _defineProperty(Poll, "ON_VOTE", 'voted');
-
 _defineProperty(Poll, "ON_RESULTS", 'results');
-
 _defineProperty(Poll, "ON_STATE_CHANGE", 'state');
 
 var Fadeable = superclass => class extends superclass {
   getFade() {
     return this.fade;
   }
-
   constructor(config) {
     super(config);
     this.fade = config.data.fade;
   }
-
 };
 
 class Powerbar extends Fadeable(Poll) {
   getResultsPerSource(source) {
     var results = null;
-
     if (typeof source === 'undefined') {
       results = this.resultsPerSource;
     } else if (typeof this.resultsPerSource[source] !== 'undefined') {
       results = this.resultsPerSource[source];
     }
-
     return results;
   }
-
   setResults(results) {
     var item = this.resultsToHistoryItem(results);
     this.results.push(item);
     this.trigger(Powerbar.ON_RESULTS, item);
   }
-
   setResultsPerSource(results) {
     results.forEach(result => {
       var item = this.resultsToHistoryItem(result.results);
-
       if (!this.resultsPerSource[result.source]) {
         this.resultsPerSource[result.source] = [];
       }
-
       this.resultsPerSource[result.source].push(item);
     }, this);
   }
-
   resultsToHistoryItem(results) {
     var item = {
       time: LViSDate.now(),
       volume: 0,
       average: 0,
       responses: 0
-    }; // option's index starts with 1
+    };
 
+    // option's index starts with 1
     for (var i = 0, l = 9; i <= l; i++) {
       if (typeof results[i] !== 'undefined') {
         item.volume += results[i] * (i + 1);
         item.responses += results[i];
       }
     }
-
     if (item.responses !== 0) {
       item.average = Math.round(item.volume / item.responses);
     }
-
     return item;
   }
-
   hasResults() {
     return this.results.length > 0;
   }
-
   constructor(config) {
     super(config);
+
     /**
      * Array of plain objects which represent result history for Powerbar element
      *
@@ -1386,25 +1154,16 @@ class Powerbar extends Fadeable(Poll) {
      * @property history
      * @type {Array}
      */
-
     this.results = [];
     this.resultsPerSource = {};
   }
-
 }
-
 _defineProperty(Powerbar, "TYPE", 'powerbar');
-
 _defineProperty(Powerbar, "STATE_STARTED", Poll.STATE_STARTED);
-
 _defineProperty(Powerbar, "STATE_CLOSED", Poll.STATE_CLOSED);
-
 _defineProperty(Powerbar, "ON_VOLUME_UPDATE", 'volume');
-
 _defineProperty(Powerbar, "ON_VOTE", Poll.ON_VOTE);
-
 _defineProperty(Powerbar, "ON_RESULTS", Poll.ON_RESULTS);
-
 _defineProperty(Powerbar, "ON_STATE_CHANGE", Poll.ON_STATE_CHANGE);
 
 var REVEAL_RESULTS_ON_VOTE = 'vote';
@@ -1413,56 +1172,45 @@ var REVEAL_RESULTS_ON_EVENT_END = 'event_end';
 var REVEAL_RESULTS_MANUALLY = 'manual';
 var REVEAL_RESULTS_NEVER = 'never';
 var REVEAL_RESULTS_ALWAYS = 'always';
-
 var Revealable = superclass => class extends superclass {
   setResults() {
     super.setResults(...arguments);
   }
-
   setResultsPerSource() {
     if (this.canReveal()) {
       super.setResultsPerSource(...arguments);
     }
   }
-
   canReveal() {
     switch (this.revealResultsMode) {
       case REVEAL_RESULTS_ON_VOTE:
         return this.hasUserVoted() || this.isClosed();
-
       case REVEAL_RESULTS_ON_CLOSE:
         return this.isClosed();
-
       case REVEAL_RESULTS_ON_EVENT_END:
       case REVEAL_RESULTS_MANUALLY:
       case REVEAL_RESULTS_ALWAYS:
         // assume that method is called upon setting results
         return true;
-
       case REVEAL_RESULTS_NEVER:
         return false;
-
       default:
         return false;
     }
   }
-
   constructor(config) {
     super(config);
     this.revealResultsMode = config.data.reveal_results_mode || REVEAL_RESULTS_ON_VOTE;
   }
-
 };
 
 var MultiVotable = superclass => class extends superclass {
   getMaxVotesPerUser() {
     return this.maxVotesPerUser;
   }
-
   getMaxVotesPerOption() {
     return this.maxVotesPerOption;
   }
-
   vote(votes) {
     var indices = Object.keys(votes);
     var maxPerUser = this.getMaxVotesPerUser();
@@ -1472,61 +1220,49 @@ var MultiVotable = superclass => class extends superclass {
     var hasNonIntVote = indices.some(idx => parseInt(votes[idx], 10) !== votes[idx]);
     var exceedsMaxPerOption = indices.find(idx => votes[idx] > maxPerOption);
     var exceedsMaxPerUser = total > maxPerUser;
-
     if (hasEmptyVote) {
       console.warn("Can't vote because one of the vote is equal or less than 0");
       return false;
     }
-
     if (hasNonIntVote) {
       console.warn("Can't vote because all votes must be integers");
       return false;
     }
-
     if (exceedsMaxPerOption) {
       console.warn('poll:%s option:%s exceeds allowed maximum:%s', this.getFullId(), +exceedsMaxPerOption + 1, maxPerOption);
       return false;
     }
-
     if (exceedsMaxPerUser) {
       console.warn('poll:%s votes:%s exceeds allowed maximum:%s', this.getFullId(), total, maxPerUser);
       return false;
     }
-
     if (total === 0) {
       console.warn("Votes can't be empty");
       return false;
     }
-
     return super.vote(votes);
   }
-
   constructor(config) {
     super(config);
     this.maxVotesPerUser = config.data.max_votes_per_user;
     this.maxVotesPerOption = config.data.max_votes_per_option;
   }
-
 };
 
 class Quiz extends Revealable(MultiVotable(Poll)) {
   isClosed() {
     return this.isStopped() || this.isRevealed();
   }
-
   isStopped() {
     return this.state === Quiz.STATE_STOPPED;
   }
-
   isRevealed() {
     return this.state === Quiz.STATE_REVEALED;
   }
-
   reveal(idx) {
     this.correctOption = idx;
     this.setState(Quiz.STATE_REVEALED);
   }
-
   stop(time) {
     // we have to force duration calculation stop
     // and force duration to 0 set because remaining
@@ -1535,104 +1271,71 @@ class Quiz extends Revealable(MultiVotable(Poll)) {
     this.abort(time);
     this.setState(Quiz.STATE_STOPPED);
   }
-
   getCorrectOption() {
     return this.correctOption;
   }
-
   vote() {
     var votes = {};
-
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     switch (args[0].constructor) {
       case Number:
         votes[args[0]] = 1;
         break;
-
       case Object:
         // keep as it is
         votes = args[0];
         break;
-
       default:
         console.warn('Incorrect votes format');
         return false;
     }
-
     var indices = Object.keys(votes);
     var hasEmptyVote = indices.some(idx => votes[idx] <= 0);
     var hasNonIntVote = indices.some(idx => !(typeof votes[idx] === 'number' && Math.floor(votes[idx]) === votes[idx]));
-
     if (hasEmptyVote) {
       console.warn("Can't vote because one of the vote is equal or less than 0");
       return false;
     }
-
     if (hasNonIntVote) {
       console.warn("Can't vote because all votes must be integers");
       return false;
     }
-
     if (indices.length > 1) {
       console.warn('Can cast vote only for one (1) option');
       return false;
     }
-
     return super.vote(votes);
   }
-
   constructor(config) {
     super(config);
     this.correctOption = {}.hasOwnProperty.call(config.data, 'correct_option') ? config.data.correct_option - 1 : null;
   }
-
 }
-
 _defineProperty(Quiz, "ON_VOTE", Poll.ON_VOTE);
-
 _defineProperty(Quiz, "ON_STATE_CHANGE", Poll.ON_STATE_CHANGE);
-
 _defineProperty(Quiz, "ON_RESULTS", Poll.ON_RESULTS);
-
 _defineProperty(Quiz, "STATE_STARTED", Poll.STATE_STARTED);
-
 _defineProperty(Quiz, "STATE_STOPPED", Poll.STATE_CLOSED);
-
 _defineProperty(Quiz, "STATE_REVEALED", 'revealed');
 
 class Prediction extends Quiz {}
-
 _defineProperty(Prediction, "TYPE", 'prediction');
-
 _defineProperty(Prediction, "STATE_STARTED", Quiz.STATE_STARTED);
-
 _defineProperty(Prediction, "STATE_STOPPED", Quiz.STATE_STOPPED);
-
 _defineProperty(Prediction, "STATE_REVEALED", Quiz.STATE_REVEALED);
-
 _defineProperty(Prediction, "ON_VOTE", Quiz.ON_VOTE);
-
 _defineProperty(Prediction, "ON_STATE_CHANGE", Quiz.ON_STATE_CHANGE);
-
 _defineProperty(Prediction, "ON_RESULTS", Quiz.ON_RESULTS);
 
 class Trivia extends Quiz {}
-
 _defineProperty(Trivia, "TYPE", 'trivia');
-
 _defineProperty(Trivia, "STATE_STARTED", Quiz.STATE_STARTED);
-
 _defineProperty(Trivia, "STATE_STOPPED", Quiz.STATE_STOPPED);
-
 _defineProperty(Trivia, "STATE_REVEALED", Quiz.STATE_REVEALED);
-
 _defineProperty(Trivia, "ON_VOTE", Quiz.ON_VOTE);
-
 _defineProperty(Trivia, "ON_STATE_CHANGE", Quiz.ON_STATE_CHANGE);
-
 _defineProperty(Trivia, "ON_RESULTS", Quiz.ON_RESULTS);
 
 class Diametric extends Poll {
@@ -1640,235 +1343,183 @@ class Diametric extends Poll {
     if (this.votedFor === null) {
       return null;
     }
-
     return Math.floor(this.votedFor / Diametric.MAX_STRENGTH);
   }
-
   getUserVoteStrength() {
     if (this.votedFor === null) {
       return null;
     }
-
     return this.votedFor % Diametric.MAX_STRENGTH + 1;
   }
-
   setResults(results) {
     results = this.calculateWeightedResults(results);
     super.setResults(results);
   }
-
   setResultsPerSource(results) {
     results.forEach(source => {
       source.results = this.calculateWeightedResults(source.results);
     }, this);
     super.setResultsPerSource(results);
   }
-
   calculateWeightedResults(results) {
-    var max = Diametric.MAX_STRENGTH; // calculate weighted results
+    var max = Diametric.MAX_STRENGTH;
 
+    // calculate weighted results
     var weighted = [0, 0];
-
     for (var i = 0; i < max; i++) {
       if (results[i]) {
         weighted[0] += (i + 1) * results[i];
       }
-
       if (results[i + max]) {
         weighted[1] += (i + 1) * results[i + max];
       }
     }
-
     return weighted;
   }
-
   vote(optionIdx, strength) {
     var min = Diametric.MIN_STRENGTH;
     var max = Diametric.MAX_STRENGTH;
     var options = this.getOptions();
-
     if (typeof optionIdx === 'undefined') {
       console.warn('Vote option is not set');
       return;
     }
-
     if (typeof strength === 'undefined') {
       console.warn('Vote strength is not set');
       return;
     }
-
     if (strength < min) {
       console.warn("Can't vote for the option %s with strength %s that is " + 'less than minimum allowed strength %s', optionIdx, strength, min);
       return;
     }
-
     if (strength > max) {
       console.warn("Can't vote for the option %s with strength %s that is " + 'more than maximum allowed strength %s', optionIdx, strength, max);
       return;
     }
-
     if (optionIdx < 0 || optionIdx > options.length - 1) {
       console.warn("Can't vote for inexistent option with idx %s", optionIdx);
       return;
     }
-
     var vote = optionIdx * max + strength - 1;
     super.vote(vote);
   }
-
   isResultsRevealed() {
     return true;
   }
-
 }
-
 _defineProperty(Diametric, "MIN_STRENGTH", 1);
-
 _defineProperty(Diametric, "MAX_STRENGTH", 5);
-
 _defineProperty(Diametric, "STATE_STARTED", Poll.STATE_STARTED);
-
 _defineProperty(Diametric, "STATE_CLOSED", Poll.STATE_CLOSED);
 
 class Swing extends Diametric {}
-
 _defineProperty(Swing, "TYPE", 'dpoll');
-
 _defineProperty(Swing, "STATE_STARTED", Diametric.STATE_STARTED);
-
 _defineProperty(Swing, "STATE_CLOSED", Diametric.STATE_CLOSED);
 
 class Emoting extends Fadeable(Diametric) {}
-
 _defineProperty(Emoting, "TYPE", 'emo');
-
 _defineProperty(Emoting, "STATE_STARTED", Diametric.STATE_STARTED);
-
 _defineProperty(Emoting, "STATE_CLOSED", Diametric.STATE_CLOSED);
 
 class Regular extends Revealable(MultiVotable(Poll)) {
   getQualifyingHashtags() {
     return this.qualifyingHashtags;
   }
-
   getMinOptionsPerVote() {
     return this.minOptionsPerVote;
   }
-
   getMaxOptionsPerVote() {
     return this.maxOptionsPerVote;
   }
-
   vote() {
     var votes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     var min = this.getMinOptionsPerVote();
     var max = this.getMaxOptionsPerVote();
     var indices = Object.keys(votes);
-
     if (indices.length < min) {
       console.warn("Count of options (%s) can't be less than minimum options per vote (%s)", indices.length, min);
       return false;
     }
-
     if (indices.length > max) {
       console.warn("Count of options (%s) can't be more than maximum options per vote (%s)", indices.length, max);
       return false;
     }
-
     return super.vote(votes);
   }
-
   constructor(config) {
     super(config);
     this.qualifyingHashtags = config.data.qualifying_hashtags;
     this.minOptionsPerVote = config.data.min_options_per_vote;
     this.maxOptionsPerVote = config.data.max_options_per_vote;
   }
-
 }
-
 _defineProperty(Regular, "TYPE", 'rpoll');
-
 _defineProperty(Regular, "STATE_STARTED", Poll.STATE_STARTED);
-
 _defineProperty(Regular, "STATE_CLOSED", Poll.STATE_CLOSED);
-
 _defineProperty(Regular, "ON_VOTE", Poll.ON_VOTE);
-
 _defineProperty(Regular, "ON_RESULTS", Poll.ON_RESULTS);
-
 _defineProperty(Regular, "ON_STATE_CHANGE", Poll.ON_STATE_CHANGE);
 
 class FlexiPoll extends Regular {}
-
 _defineProperty(FlexiPoll, "TYPE", 'poll');
-
 _defineProperty(FlexiPoll, "STATE_STARTED", Regular.STATE_STARTED);
-
 _defineProperty(FlexiPoll, "STATE_CLOSED", Regular.STATE_CLOSED);
-
 _defineProperty(FlexiPoll, "ON_VOTE", Regular.ON_VOTE);
-
 _defineProperty(FlexiPoll, "ON_RESULTS", Regular.ON_RESULTS);
-
 _defineProperty(FlexiPoll, "ON_STATE_CHANGE", Regular.ON_STATE_CHANGE);
 
+var _PollFactory;
 class PollFactory extends FrameFactory {
   vote(enmasseId, vote) {
     var poll = this.getByEnmasseId(enmasseId);
     var args = [enmasseId, vote, ''];
     Enmasse.send(poll._channel, 'v', args);
   }
-
   processMessages() {
     var i = 0;
-    var message; // loop through the loop and process each item
+    var message;
 
+    // loop through the loop and process each item
     while (i < this.messages.length) {
-      message = this.messages[i]; // trying to find existent instance
+      message = this.messages[i];
 
+      // trying to find existent instance
       var enmasseId = parseInt(message.body[0], 10);
-      var poll = this.getByEnmasseId(enmasseId); // if poll doesn't exist
+      var poll = this.getByEnmasseId(enmasseId);
 
+      // if poll doesn't exist
       if (!poll) {
         i++;
         continue;
       }
+      this.instances[poll.getId()]._channel = message.channel;
 
-      this.instances[poll.getId()]._channel = message.channel; // remove processed item from the queue
-
+      // remove processed item from the queue
       this.messages.splice(i, 1);
-
       switch (message.klass) {
         case PollFactory.MSG_CLASS_POLL:
           this.processPollMessage(poll, message);
           break;
-
         case PollFactory.MSG_CLASS_FB:
           this.processFeedbackMessage(poll, message);
           break;
-
         case PollFactory.MSG_CLASS_STOP:
           this.processStopMessage(poll, message);
           break;
-
         case PollFactory.MSG_CLASS_REVEAL:
           this.processRevealMessage(poll, message);
           break;
       }
     }
   }
-  /* eslint-disable no-unused-vars */
-
 
-  processPollMessage(poll
-  /* , message */
-  ) {
+  /* eslint-disable no-unused-vars */
+  processPollMessage(poll /* , message */) {
     poll.finalize();
   }
   /* eslint-enable no-unused-vars */
 
-
   processFeedbackMessage(poll, message) {
     var hasSource = !!message.body[2];
     var hasCounters = !!message.body[3];
@@ -1876,15 +1527,15 @@ class PollFactory extends FrameFactory {
     var sources = hasSource ? message.body[2].split(':') : [];
     var counters = hasCounters ? message.body[3].split(':') : [];
     var results = [];
-    var resultsPerSource = []; // converting counters to integer
+    var resultsPerSource = [];
 
+    // converting counters to integer
     counters = counters.map(counter => +counter);
     counters.forEach((counter, i) => {
       var total = counters.length / (sources.length / 2);
       var idx = i % total;
       results[idx] = +counter + (results[idx] || 0);
     });
-
     for (var i = 0, l = sources.length / 2; i < l; i++) {
       var total = counters.length / (sources.length / 2);
       resultsPerSource.push({
@@ -1893,22 +1544,19 @@ class PollFactory extends FrameFactory {
         results: counters.slice(total * i, total * i + total)
       });
     }
-
     if (results.length > 0 || isFinal) {
       poll.setResultsPerSource(resultsPerSource);
       poll.setResults(results);
     }
   }
-
   processStopMessage(poll, message) {
     poll.stop(message.body[1]);
   }
-
   processRevealMessage(poll, message) {
     poll.reveal(message.body[1] - 1);
-  } // TODO: combine create() and createSnapshot() methods
-
+  }
 
+  // TODO: combine create() and createSnapshot() methods
   create(data) {
     super.create(data);
     var Constructor = this.getConstructorByType(data.type);
@@ -1918,7 +1566,6 @@ class PollFactory extends FrameFactory {
     poll.bind(Poll.ON_VOTE, this.handleVote.bind(this, poll));
     return poll;
   }
-
   createSnapshot(data) {
     super.createSnapshot(data);
     var Constructor = this.getConstructorByType(data.type);
@@ -1927,132 +1574,101 @@ class PollFactory extends FrameFactory {
     poll.finalize();
     return poll;
   }
-
   setMessage(message) {
     if (PollFactory.MSG_CLASSES.indexOf(message.klass) === -1) {
       return;
     }
-
     this.messages.push(message);
     this.processMessages();
   }
-
   getConstructorByType(type) {
     switch (type) {
       case Powerbar.TYPE:
         return Powerbar;
-
       case Prediction.TYPE:
         return Prediction;
-
       case Trivia.TYPE:
         return Trivia;
-
       case Swing.TYPE:
         return Swing;
-
       case Emoting.TYPE:
         return Emoting;
-
       case Regular.TYPE:
         return Regular;
-
       case FlexiPoll.TYPE:
         return FlexiPoll;
-
       default:
         return undefined;
     }
   }
-
   handleVote(instance, vote) {
     var idx;
     var cast = [];
-
     switch (instance.getType()) {
       case Regular.TYPE:
       case FlexiPoll.TYPE:
       case Prediction.TYPE:
       case Trivia.TYPE:
         break;
-
       default:
         idx = vote;
         vote = {};
         vote[idx] = 1;
         break;
     }
-
     for (idx in vote) {
       if ({}.hasOwnProperty.call(vote, idx)) {
         cast = cast.concat([+idx + 1, vote[idx]]);
       }
     }
-
     this.vote(instance.getEnmasseId(), cast.join(':'));
   }
-
   constructor() {
-    super(); // a queue of messages on poll's channel
+    super();
 
+    // a queue of messages on poll's channel
     this.messages = [];
   }
-
 }
-
+_PollFactory = PollFactory;
 _defineProperty(PollFactory, "MSG_CLASS_POLL", 'p');
-
 _defineProperty(PollFactory, "MSG_CLASS_FB", 'fb');
-
 _defineProperty(PollFactory, "MSG_CLASS_STOP", 'stop');
-
 _defineProperty(PollFactory, "MSG_CLASS_REVEAL", 'reveal');
-
-_defineProperty(PollFactory, "MSG_CLASSES", [PollFactory.MSG_CLASS_POLL, PollFactory.MSG_CLASS_FB, PollFactory.MSG_CLASS_STOP, PollFactory.MSG_CLASS_REVEAL]);
+_defineProperty(PollFactory, "MSG_CLASSES", [_PollFactory.MSG_CLASS_POLL, _PollFactory.MSG_CLASS_FB, _PollFactory.MSG_CLASS_STOP, _PollFactory.MSG_CLASS_REVEAL]);
 
 class Data extends Frame {
   getState() {
     return this.state;
   }
-
   setState(state) {
     // do not fire state change if passed state is the same as it was
     if (state === this.state) {
       return;
     }
-
     this.state = state;
     this.trigger(Data.ON_STATE_CHANGE, state);
   }
-
   updateDurationLeft() {
     super.updateDurationLeft();
-
     if (this.durationLeft > 0) {
       this.setState(Data.STATE_STARTED);
     } else {
       this.setState(Data.STATE_CLOSED);
     }
   }
-
   update() {
     var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     super.update(config);
     this.publishedAt = config.published_at - 0 || 0;
-
     if (this.fixed) {
       this.updateDurationLeft();
     }
   }
-
 }
-
 _defineProperty(Data, "TYPE", 'data');
-
 _defineProperty(Data, "STATE_STARTED", 'started');
-
 _defineProperty(Data, "STATE_CLOSED", 'closed');
-
 _defineProperty(Data, "ON_STATE_CHANGE", 'state');
 
 class DataFactory extends FrameFactory {
@@ -2063,35 +1679,28 @@ class DataFactory extends FrameFactory {
     this.instances[data.id] = element;
     return element;
   }
-
   createSnapshot(data) {
     super.createSnapshot(data);
     return this.create(data);
   }
-
 }
 
 class Curation extends Entity {
   getText() {
     return this.text;
   }
-
   getSender() {
     return this.sender;
   }
-
   getSenderName() {
     return this.senderName;
   }
-
   getSenderPicure() {
     return this.senderPicture;
   }
-
   getSource() {
     return this.source;
   }
-
   constructor(config) {
     super(config);
     this.text = config.data.text;
@@ -2100,11 +1709,8 @@ class Curation extends Entity {
     this.senderPicture = config.data.sender_picture;
     this.source = config.data.source;
   }
-
 }
-
 _defineProperty(Curation, "TYPE", 'curation');
-
 _defineProperty(Curation, "SOURCE_TWITTER", 'twitter');
 
 class CurationFactory extends Base {
@@ -2114,71 +1720,48 @@ class CurationFactory extends Base {
     this.instances[data.id] = curation;
     return curation;
   }
-
   createSnapshot(data) {
     super.createSnapshot(data);
     return this.create(data);
   }
-
 }
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 var Factories = (() => {
   var self = {};
   var channels = {};
   var factories = [];
-  var factoriesByChannel = {}; // Hash of factories instances keyed on frame type.
+  var factoriesByChannel = {};
 
+  // Hash of factories instances keyed on frame type.
   self.items = {};
-
   var handleMessage = msg => {
     // console.log("Factories::handleMessage", msg);
+
     // get factory by channel id
     var factory = getFactoryByChannel(msg.channel);
-
     if (factory !== null) {
       factory.setMessage(msg);
     }
-
     return null;
   };
-
   var getFactoryByChannel = channel => {
     for (var key in channels) {
       if ({}.hasOwnProperty.call(channels, key) && channels[key] === channel) {
         return factoriesByChannel[key] || null;
       }
     }
-
     return null;
   };
-
   self.destroyInstances = () => {
-    var _iterator = _createForOfIteratorHelper(factories),
-        _step;
-
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var factory = _step.value;
-        factory.destroyInstances();
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+    for (var _i = 0, _factories = factories; _i < _factories.length; _i++) {
+      var factory = _factories[_i];
+      factory.destroyInstances();
     }
   };
-
   self.setChannels = ch => {
     channels = ch;
   };
-
   self.get = type => self.items[type];
-
   self.init = () => {
     var data = [{
       Constructor: PollFactory,
@@ -2196,68 +1779,58 @@ var Factories = (() => {
     data.forEach(item => {
       var factory = new item.Constructor();
       factories.push(factory);
-
       if (item.channel !== null) {
         factoriesByChannel[item.channel] = factory;
       }
-
       item.types.forEach(type => {
         self.items[type] = factory;
       });
     });
     ConnectionAdaptor.bind(ConnectionAdaptor.ON_MESSAGE, handleMessage);
   };
-
   return self;
 })();
 
+// Listens on control channel for create and delete messages.
 // Constructor takes main control channel id. No methods.
-
 function Control(config) {
   config = config || {};
   var self = this;
   var _config = config,
-      channel = _config.channel;
+    channel = _config.channel;
   this.trigger = this.emit;
   this.bind = this.on;
   this.unbind = this.off;
-
   var handleMessage = message => {
     // channel and type should match settings
     if (message.channel !== channel) {
       return;
     }
-
     switch (message.klass) {
       case Control.MSG_TYPE_CREATE:
         handleMessageCreate(message);
         break;
-
       case Control.MSG_TYPE_REVOKE:
         handleMessageRevoke(message);
         break;
     }
   };
-
   var handleEOC = _channel => {
     // channel and type should match settings
     if (_channel !== channel) {
       return;
     }
-
     self.trigger(Control.MSG_TYPE_EOC);
   };
-
   var handleMessageCreate = message => {
     var data = JSON.parse(message.body[0]);
     var factory = Factories.get(data.type);
-
     if (typeof factory === 'undefined') {
       return;
     }
+    var instance = factory.get(data.id);
 
-    var instance = factory.get(data.id); // secure runtime against broken data
-
+    // secure runtime against broken data
     try {
       if (instance) {
         self.update(data);
@@ -2268,55 +1841,45 @@ function Control(config) {
       console.error(e);
     }
   };
-
   var handleMessageRevoke = message => {
     var data = JSON.parse(message.body[0]);
     self.revoke(data);
   };
-
   self.create = data => {
     var factory = Factories.get(data.type);
-    var instance = factory.create(data); // trigger MSG_TYPE_CREATE only if instance is finalized
+    var instance = factory.create(data);
 
+    // trigger MSG_TYPE_CREATE only if instance is finalized
     Deferred.when(instance.finalized).done(() => {
       self.trigger(Control.MSG_TYPE_CREATE, instance);
     });
   };
-
   self.update = data => {
     var factory = Factories.get(data.type);
     var instance = factory.get(data.id);
     factory.update(instance, data);
     self.trigger(Control.MSG_TYPE_UPDATE, instance);
   };
-
   self.revoke = data => {
     var factory = Factories.get(data.type);
-
     if (typeof factory === 'undefined') {
       return;
     }
-
     var instance = factory.get(data.id);
-
     if (!instance) {
       return;
     }
-
     factory.revoke(data.id);
     self.trigger(Control.MSG_TYPE_REVOKE, instance);
   };
-
   self.destroy = () => {
     // destroy all elements instances
     Factories.destroyInstances();
     ConnectionAdaptor.unbind(ConnectionAdaptor.ON_MESSAGE, handleMessage);
   };
-
   ConnectionAdaptor.bind(ConnectionAdaptor.ON_MESSAGE, handleMessage);
   ConnectionAdaptor.bind(ConnectionAdaptor.ON_EOC, handleEOC);
 }
-
 Control.prototype = assignIn(Control.prototype, new Emitter());
 Control.MSG_TYPE_CREATE = 'create';
 Control.MSG_TYPE_UPDATE = 'update';
@@ -2336,24 +1899,24 @@ var Event = function Event(uuid) {
    * Settings
    */
   uuid = uuid || null;
+
   /*
    * Private properties
    */
-
   var self = this;
   var state = Event.STATE_PENDING;
   var data = {};
   var history = []; // list of all past and current elements in this episode
-
   var control = null;
   this.trigger = this.emit;
   this.bind = this.on;
   this.unbind = this.off;
+
   /*
    * Public properties
    */
-
   self.ready = new Deferred();
+
   /*
    * Private methods
    */
@@ -2364,40 +1927,32 @@ var Event = function Event(uuid) {
     var startAt = self.get('start_at');
     var delay = self.get('__delay');
     var extraTime = self.get('extra_time');
-
     var newState = (() => {
       if (isDataEmpty()) {
-        return Event.STATE_PENDING; // flag `started` is used to determine if event is manual,
+        return Event.STATE_PENDING;
+        // flag `started` is used to determine if event is manual,
         // in this case start time is ahead of current timestamp
       }
-
       if (!self.get('started') || now < startAt) {
         return Event.STATE_UPCOMING;
       }
-
       if (now < endAt) {
         return Event.STATE_ACTIVE;
       }
-
       if (now < endAt - delay + extraTime) {
         return Event.STATE_PROLONGED;
       }
-
       return Event.STATE_FINISHED;
     })();
-
     if (newState !== state) {
       setState(newState);
     }
-
     Run.nextPriority(() => calculateState());
   };
-
   var initControl = () => {
     if (control !== null) {
       return;
     }
-
     control = new Control({
       channel: self.getChannels(CHANNEL_CONTROL)
     });
@@ -2406,28 +1961,26 @@ var Event = function Event(uuid) {
     control.bind(Control.MSG_TYPE_REVOKE, handleControlRevoke);
     control.bind(Control.MSG_TYPE_EOC, handleControlEOC);
   };
-
   var setState = newState => {
     var oldState = self.getState();
     state = newState;
-
     if (oldState !== self.getState()) {
       self.trigger(Event.ON_STATE, self.getState());
     }
-
     self.trigger(Event.ON_SUBSTATE, self.getSubstate());
   };
-
   var processHistory = _ref => {
     var timeline = _ref.timeline,
-        config = _ref.config;
+      config = _ref.config;
     var snapshots = timeline.map(item => item);
-    snapshots.forEach(ConnectionAdaptor.adaptSnapshotData); // elements to revoke
+    snapshots.forEach(ConnectionAdaptor.adaptSnapshotData);
+
+    // elements to revoke
     //
     // skipping this phase as `/revoke` message is preserved on enmasse
     // channels until the end of an event
-    // elements to create
 
+    // elements to create
     snapshots.filter(snapshot => !getElementFromHistory(snapshot.id)).map(snapshot => {
       var factory = Factories.get(snapshot.type);
       return factory.createSnapshot(snapshot);
@@ -2441,49 +1994,44 @@ var Event = function Event(uuid) {
       factory.update(element, snapshot);
       return element;
     }).forEach(handleControlUpdate);
-
     if (isDataEmpty()) {
       ConnectionAdaptor.adaptEvent(config);
       self.setData(config);
     }
   };
-
   var isDataEmpty = () => {
     if (!data || typeof data !== 'object' || Array.isArray(data)) {
       return false;
     }
-
     return !Object.keys(data).length;
   };
-
   var isReady = () => self.ready.state() === 'resolved';
-
   var isElementInHistory = element => history.some(historyElement => historyElement.getId() === element.getId());
-
   var canLoadHistory = () => {
     // time to ignore history loading
-    var ignore = parseInt(Project.get('history_ignore'), 10) || 60; // delay at the moment of time when event's data were adapted
+    var ignore = parseInt(Project.get('history_ignore'), 10) || 60;
 
-    var delay = self.get('__delay'); // even'ts start time (including delay)
+    // delay at the moment of time when event's data were adapted
+    var delay = self.get('__delay');
 
-    var start = self.get('start_at'); // do not load history if now before this time
+    // even'ts start time (including delay)
+    var start = self.get('start_at');
 
+    // do not load history if now before this time
     var threshold = start - delay + ignore;
     return self.isPending() || LViSDate.now() > threshold;
   };
-
   var addElementToHistory = element => {
     if (isElementInHistory(element)) {
       return;
-    } // sort by published at and id
-
+    }
 
+    // sort by published at and id
     for (var i = history.length - 1; i >= 0; i--) {
       if (history[i].publishedAt < element.publishedAt) {
         history.splice(i + 1, 0, element);
         return;
       }
-
       if (history[i].publishedAt === element.publishedAt) {
         if (history[i].id < element.id) {
           history.splice(i + 1, 0, element);
@@ -2491,144 +2039,112 @@ var Event = function Event(uuid) {
         }
       }
     }
-
     history.unshift(element);
   };
-
   var getElementFromHistory = id => history.find(element => element.getId() === id);
-
   var removeElementFromHistory = element => {
     var index = history.indexOf(element);
-
     if (index > -1) {
       history.splice(index, 1);
     }
   };
-
   var sortElementsInHistory = () => {
     history.sort((a, b) => a.getPublishedAt() - b.getPublishedAt());
   };
-
   var handleControlCreate = instance => {
     addElementToHistory(instance);
-
     if (isReady()) {
       self.trigger(Event.ON_ELEMENT_PUBLISH, instance);
     }
   };
-
   var handleControlUpdate = instance => {
     sortElementsInHistory();
-
     if (isReady()) {
       self.trigger(Event.ON_ELEMENT_UPDATE, instance);
     }
   };
-
   var handleControlRevoke = instance => {
     removeElementFromHistory(instance);
-
     if (isReady()) {
       self.trigger(Event.ON_ELEMENT_REVOKE, instance);
     }
   };
-
   var handleControlEOC = () => {
     self.trigger(Event.ON_EOC);
   };
+
   /*
    * Getters
    */
 
-
   this.get = param => {
     if (typeof param === 'undefined') {
       // return full dataset if parameter is not set
       return data;
     }
-
     if (typeof data[param] !== 'undefined') {
       // return value that matches passed parameter in dataset
       return data[param];
     }
-
     return null;
   };
-
   this.getUUID = () => uuid;
-
   this.getChannels = type => {
     var channelId = t => "".concat(t, "-").concat(uuid);
-
     if (typeof type === 'undefined') {
       return {
         poll: channelId(CHANNEL_POLL),
         control: channelId(CHANNEL_CONTROL)
       };
     }
-
     if (type === CHANNEL_POLL || type === CHANNEL_CONTROL) {
       return channelId(type);
     }
-
     throw new Error("Unknown channel type ".concat(type));
   };
-
   this.getName = () => this.get('name');
-
   this.getStartAt = () => this.get('start_at');
-
   this.getOriginalStartAt = () => {
     var startAt = this.getStartAt();
-
     if (startAt === null) {
       return null;
     }
-
     return startAt - data.__delay;
   };
-
   this.getEndAt = () => this.get('end_at');
-
   this.getState = () => {
     switch (state) {
       case Event.STATE_PROLONGED:
         return Event.STATE_FINISHED;
-
       default:
         return state;
     }
   };
-
   this.getSubstate = () => state;
-
   this.getCustomFields = field => {
     var fields = this.get('custom_fields');
-
     if (fields === null) {
       return null;
     }
-
     var values = Project.localise(fields);
-
     if (typeof field === 'undefined') {
       // return full set of custom fields if field name wasn't passed
       return values;
-    } // custom field was passed
-
+    }
 
+    // custom field was passed
     if (typeof values[field] !== 'undefined') {
       // return specific field if field exists in object
       return values[field];
-    } // otherwise return null
-
+    }
 
+    // otherwise return null
     return null;
   };
-
   this.getCountdown = format => {
-    format = format || TIME_FORMAT_SECONDS; // countdown values
+    format = format || TIME_FORMAT_SECONDS;
 
+    // countdown values
     var countdown = {
       years: 0,
       months: 0,
@@ -2638,18 +2154,17 @@ var Event = function Event(uuid) {
       seconds: 0
     };
     var diffSeconds = this.get('start_at') - LViSDate.now();
-
     if (diffSeconds < 0) {
       diffSeconds = 0;
     }
-
     if (format === TIME_FORMAT_SECONDS) {
       return diffSeconds;
-    } // calculate difference between event start at and now dates relatively to the Unix Epoch time
-
+    }
 
-    var diff = new Date(diffSeconds * 1000); // methods to be casted on diff date
+    // calculate difference between event start at and now dates relatively to the Unix Epoch time
+    var diff = new Date(diffSeconds * 1000);
 
+    // methods to be casted on diff date
     var methods = {
       years: 'getUTCFullYear',
       months: 'getUTCMonth',
@@ -2659,97 +2174,74 @@ var Event = function Event(uuid) {
       seconds: 'getUTCSeconds'
     };
     var value;
-
     for (var _i = 0, _Object$entries = Object.entries(methods); _i < _Object$entries.length; _i++) {
       var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-          key = _Object$entries$_i[0],
-          method = _Object$entries$_i[1];
-
+        key = _Object$entries$_i[0],
+        method = _Object$entries$_i[1];
       value = diff[method]();
-
       switch (method) {
         case 'getUTCDate':
           value--; // date starts with 1 not 0
-
           break;
-
         case 'getUTCFullYear':
           value -= 1970; // year when Unix Epoch started
-
           break;
       }
-
       countdown[key] = value;
     }
-
     switch (format) {
       case TIME_FORMAT_OBJECT:
         return countdown;
-
       case TIME_FORMAT_ARRAY:
         return [countdown.seconds, countdown.minutes, countdown.hours, countdown.days, countdown.months, countdown.years];
-
       default:
         // undefined format?
         return null;
     }
   };
-
   this.getHistory = () => history;
-
   this.getLastFromHistory = () => {
     if (history.length > 0) {
       return history[history.length - 1];
     }
-
     return null;
   };
+
   /*
    * Public methods
    */
 
-
   this.setData = newData => {
     var oldDigest = data.digest;
     var oldDelay = data.__delay;
     data = newData || {};
-
     if (oldDigest !== newData.digest || oldDelay !== newData.__delay) {
       self.trigger(Event.ON_UPDATE);
     }
-
     calculateState();
   };
-
   this.isPending = () => state === Event.STATE_PENDING;
-
   this.isReady = () => isReady();
-
   this.addDemographicsCounter = (segmentName, segmentValue, counter, round, min, max) => {
     if (this.isPending()) {
       console.error("Can't add demographics counter while event is in the pending state.");
       return;
     }
-
     var channel = this.getChannels(CHANNEL_CONTROL);
     var segment = [segmentName, segmentValue];
     Enmasse.Demographics.addCounter(channel, uuid, segment, counter, round, min, max);
   };
-
   this.markAsReady = () => {
     if (isReady()) {
       return;
     }
-
     self.ready.resolve();
     self.trigger(Event.ON_READY);
   };
-
   this.markAsNotReady = () => {
     if (!isReady()) {
       return;
     }
-
     history.map(element => ({
       id: element.getId(),
       type: element.getType()
@@ -2759,6 +2251,7 @@ var Event = function Event(uuid) {
     self.ready = new Deferred();
     self.trigger(Event.ON_NOT_READY);
   };
+
   /**
    * Loads event's history from CDN
    *
@@ -2768,11 +2261,8 @@ var Event = function Event(uuid) {
    * @param {boolean} [reconnect=false] Indicates that history is loading on reconnect
    * @return {deferred} of ajax request
    */
-
-
   this.loadHistory = (host, reconnect) => {
     var deferred = new Deferred();
-
     var success = historyData => {
       try {
         // secure code against the bad data
@@ -2780,18 +2270,14 @@ var Event = function Event(uuid) {
       } catch (exception) {
         console.error(exception);
       }
-
       deferred.resolve();
     };
-
     var error = () => {
       if (self.isPending()) {
         setState(Event.STATE_FAILURE);
       }
-
       deferred.reject();
     };
-
     if (canLoadHistory()) {
       var url = "".concat(host, "/events/").concat(uuid.substr(0, 2), "/").concat(uuid, "/history.json");
       xhr.get(url, {
@@ -2801,13 +2287,13 @@ var Event = function Event(uuid) {
         var status = resp.statusCode;
         var isSuccess = status >= 200 && status <= 300 || status === 0 || status === '';
         var hasTimeline = {}.hasOwnProperty.call(historyData, 'timeline');
-        var hasConfig = {}.hasOwnProperty.call(historyData, 'config'); // Assert on race condition when the event becomes ready before
-        // history is loaded. Not applicable on reconnect.
+        var hasConfig = {}.hasOwnProperty.call(historyData, 'config');
 
+        // Assert on race condition when the event becomes ready before
+        // history is loaded. Not applicable on reconnect.
         if (isReady() && !reconnect) {
           console.warn('Event is ready before history is loaded');
         }
-
         if (isSuccess && hasTimeline && hasConfig) {
           success(historyData);
         } else {
@@ -2817,14 +2303,11 @@ var Event = function Event(uuid) {
     } else {
       deferred.resolve();
     }
-
     return deferred;
   };
-
   calculateState();
   initControl();
 };
-
 Event.prototype = assignIn(Event.prototype, new Emitter());
 Event.ON_READY = 'ready';
 Event.ON_NOT_READY = 'not-ready';
@@ -2840,27 +2323,28 @@ Event.STATE_PENDING = 'pending';
 Event.STATE_UPCOMING = 'upcoming';
 Event.STATE_ACTIVE = 'active';
 Event.STATE_PROLONGED = 'prolonged'; // substate of STATE_FINISHED
-
 Event.STATE_FINISHED = 'finished';
 Event.HISTORY_LOCALISATION = 1;
 Event.HISTORY_VERSIONS = {
   2: Event.HISTORY_LOCALISATION
 };
 
+// properties
 var channel$1 = null;
 var events = [];
 var assets = {};
 var instances = {}; // cache of instances
-
 var ready = false;
 var Listings = new Emitter();
 Listings.trigger = Listings.emit;
 Listings.bind = Listings.on;
-Listings.unbind = Listings.off; // constants
+Listings.unbind = Listings.off;
 
+// constants
 Listings.ON_READY = 'ready';
 Listings.ON_UPDATE = 'update';
 Listings.MSG_CLASS = 'listings';
+
 /*
  * Private methods
  */
@@ -2870,7 +2354,6 @@ var handleMessage = msg => {
   if (msg.channel !== channel$1) {
     return;
   }
-
   switch (msg.klass) {
     case Listings.MSG_CLASS:
       {
@@ -2880,53 +2363,50 @@ var handleMessage = msg => {
       }
   }
 };
-
 var handleEOC = _channel => {
   if (_channel !== channel$1) {
     return;
-  } // do not expose ON_READY event if listings were initialised already
-
+  }
 
+  // do not expose ON_READY event if listings were initialised already
   if (!ready) {
     ready = true;
     Listings.trigger(Listings.ON_READY);
   }
 };
-
 var findById = (collection, id) => {
   for (var i = 0, l = collection.length; i < l; i++) {
     if (collection[i].id === id) {
       return collection[i];
     }
   }
-
   return null;
-}; // check if there are any changes in listings data
-
+};
 
+// check if there are any changes in listings data
 var haveChanged = data => {
   var i;
   var l;
-  var event; // iterate over came events data
+  var event;
 
+  // iterate over came events data
   for (i = 0, l = data.events.length; i < l; i++) {
-    event = findById(events, data.events[i].id); // new episode OR digest of the existant event has changed
+    event = findById(events, data.events[i].id);
 
+    // new episode OR digest of the existant event has changed
     if (event === null || event.digest !== data.events[i].digest) {
       return true;
     }
-  } // check if event was removed
-
+  }
 
+  // check if event was removed
   for (i = 0, l = events.length; i < l; i++) {
     if (findById(data.events, events[i].id) === null) {
       return true;
     }
   }
-
   return false;
 };
-
 var handleData = data => {
   var isChanges = ready && haveChanged(data);
   events = data.events;
@@ -2934,170 +2414,153 @@ var handleData = data => {
     if (a.start_at < b.start_at) {
       return -1;
     }
-
     if (a.start_at > b.start_at) {
       return 1;
     }
-
     return 0;
-  }); // populate project object with the data
+  });
 
+  // populate project object with the data
   Project.setData(data.project);
-
   if (!ready) {
     // load assets only once
     // and cache them permanently
     assets = data.assets;
-  } // update instances
-
+  }
 
+  // update instances
   for (var i = 0, l = events.length; i < l; i++) {
     var event = events[i];
-
     if (instances[event.id]) {
       instances[event.id].setData(event);
     }
   }
-
   if (isChanges) {
     Listings.trigger(Listings.ON_UPDATE);
   }
 };
+
 /*
  * Public methods
  */
-// returns object of the LViS event by Id
-
 
+// returns object of the LViS event by Id
 Listings.get = id => {
   // lazy return if instance already exists
   if (typeof instances[id] !== 'undefined') {
     return instances[id];
   }
-
   var data = findById(events, id);
-  var event = new Event(id); // Data from Enmasse has priority over data from CDN
-  // Setting data from listings if data exists
+  var event = new Event(id);
 
+  // Data from Enmasse has priority over data from CDN
+  // Setting data from listings if data exists
   if (data) {
     event.setData(data);
   }
-
   instances[id] = event;
   return event;
-}; // Current episode is the episode start time
+};
+
+// Current episode is the episode start time
 // of which in the past and end time in future.
 // Returns:
 //   1) array of the currently active LViS Events
 //   2) NULL if there are no any LViS Event
-
-
 Listings.getCurrent = () => {
   var list = [];
-  var now = LViSDate.now(); // loop through the raw data
+  var now = LViSDate.now();
 
+  // loop through the raw data
   for (var i = 0, l = events.length; i < l; i++) {
     if (events[i].start_at <= now && now < events[i].end_at) {
       list.push(Listings.get(events[i].id));
     }
-  } // return NULL if nothing found
-
+  }
 
+  // return NULL if nothing found
   return list.length ? list : null;
-}; // Returns:
+};
+
+// Returns:
 //   1) array of the LViS Events that are
 //      scheduled to start next
 //   2) NULL if there are no any LViS Event
-
-
 Listings.getNext = () => {
   // time till the next event
   var nextStartAt = Number.POSITIVE_INFINITY;
-  var list = []; // loop through the raw data and find
-  // the minimal time till the upcoming event
+  var list = [];
 
+  // loop through the raw data and find
+  // the minimal time till the upcoming event
   var i;
   var l;
   var now = LViSDate.now();
-
   for (i = 0, l = events.length; i < l; i++) {
     if (now < events[i].start_at && events[i].start_at < nextStartAt) {
       nextStartAt = events[i].start_at;
     }
   }
-
   if (nextStartAt < Number.POSITIVE_INFINITY) {
     for (i = 0, l = events.length; i < l; i++) {
       if (events[i].start_at === nextStartAt) {
         list.push(Listings.get(events[i].id));
       }
     }
-  } // return NULL if nothing found
-
+  }
 
+  // return NULL if nothing found
   return list.length ? list : null;
-}; // can't be realized now due to absence of
+};
+
+// can't be realized now due to absence of
 // the ended events in the list
 // Listings.getPrevious = function () {};
+
 // returns the list of all events sorted by start time
 // eslint-disable-next-line
-
-
 Listings.getList = function () {
   var event;
   var list = [];
-
   for (var i = 0, l = events.length; i < l; i++) {
     event = this.get(events[i].id);
-
     if (event !== null) {
       list.push(event);
     }
   }
-
   return list;
 };
-
 Listings.getAssets = id => {
   if (typeof id === 'undefined') {
     return assets;
   }
-
   return assets[id] || null;
 };
-
 Listings.fetchListings = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(host, project) {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(host, project) {
     var response, data;
-    return _regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return fetch("https://".concat(host, "/projects/").concat(project.substr(0, 2), "/").concat(project, "/listings.json"));
-
-          case 2:
-            response = _context.sent;
-            _context.next = 5;
-            return response.json();
-
-          case 5:
-            data = _context.sent;
-            handleData(data);
-
-          case 7:
-          case "end":
-            return _context.stop();
-        }
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 1;
+          return fetch("https://".concat(host, "/projects/").concat(project.substr(0, 2), "/").concat(project, "/listings.json"));
+        case 1:
+          response = _context.sent;
+          _context.next = 2;
+          return response.json();
+        case 2:
+          data = _context.sent;
+          handleData(data);
+        case 3:
+        case "end":
+          return _context.stop();
       }
     }, _callee);
   }));
-
   return function (_x, _x2) {
     return _ref.apply(this, arguments);
   };
 }();
-
 Listings.init = config => {
   config = config || {};
   channel$1 = config.channel || null;
@@ -3108,20 +2571,17 @@ Listings.init = config => {
 var User = (() => {
   // pointer to `this` object
   var self = {};
-
   self.getSessionId = () => Enmasse.getSessionId();
-
   self.signIn = function () {
     return Enmasse.signIn(...arguments);
   };
-
   self.login = function () {
     return Enmasse.login(...arguments);
   };
-
   return self;
 })();
 
+// properties
 var host = null;
 var channel = null;
 var lvisEvent = null;
@@ -3141,8 +2601,9 @@ var ON_READY = 'ready';
 var ON_ERROR = 'error';
 LViS.trigger = trigger;
 LViS.bind = bind;
-LViS.unbind = unbind; // attach xhr library to make it possible to mock it in unit tests
+LViS.unbind = unbind;
 
+// attach xhr library to make it possible to mock it in unit tests
 LViS._xhr = xhr;
 LViS.VERSION = version;
 LViS.ON_READY = ON_READY;
@@ -3186,6 +2647,7 @@ LViS.Trivia = Trivia;
 LViS.Diametric = Diametric;
 LViS.Swing = Swing;
 LViS.Emoting = Emoting;
+
 /*
  * Private methods
  */
@@ -3194,34 +2656,27 @@ var embedAssets = () => {
   var jsLoaded = new Deferred();
   var i;
   var files = {}; // list of files grouped by type
-
   var assets = getAssets();
-
   for (var key in assets) {
     if ({}.hasOwnProperty.call(assets, key)) {
       for (i = 0; i < assets[key].length; i++) {
         var asset = assets[key][i];
         var type = asset.autoload;
-
         if (typeof type === 'undefined') {
           continue;
         }
-
         if (typeof files[type] === 'undefined') {
           files[type] = [];
         }
-
         files[type].push(asset.data);
       }
     }
   }
-
   if (typeof files.js !== 'undefined' && files.js.length > 0) {
     $script(files.js, jsLoaded.resolve());
   } else {
     jsLoaded.resolve();
   }
-
   if (typeof files.css !== 'undefined' && files.css.length > 0) {
     for (i = 0; i < files.css.length; i++) {
       if (document.createStyleSheet) {
@@ -3236,23 +2691,20 @@ var embedAssets = () => {
       }
     }
   }
-
   return Deferred.when(jsLoaded);
 };
-
 var handleEventState = () => {
   if (lvisEvent === null) {
     return;
-  } // console.log("LViS::handleEventState", lvisEvent.getSubstate());
+  }
 
+  // console.log("LViS::handleEventState", lvisEvent.getSubstate());
 
   var state = lvisEvent.getSubstate();
-
   if ([Event.STATE_FAILURE, Event.STATE_UPCOMING, Event.STATE_FINISHED].indexOf(state) >= 0) {
     // no more data to load
     lvisEvent.markAsReady();
   }
-
   switch (state) {
     // case Event.STATE_PENDING: break;
     // case Event.STATE_FAILURE:
@@ -3261,136 +2713,118 @@ var handleEventState = () => {
     case Event.STATE_ACTIVE:
       handleEventActiveState();
       break;
-
     case Event.STATE_PROLONGED:
       handleEventProlongedState();
       break;
-
     case Event.STATE_FINISHED:
       handleEventFinishedState();
       break;
   }
 };
-
 var handleEventEOC = () => {
   lvisEvent.markAsReady();
 };
-
 var handleEventActiveState = () => {
   // console.log("LViS::handleEventActiveState");
   var channels = lvisEvent.getChannels();
-  Factories.setChannels(channels); // subscribe to all channels and kick the things off
+  Factories.setChannels(channels);
 
+  // subscribe to all channels and kick the things off
   for (var key in channels) {
     if ({}.hasOwnProperty.call(channels, key)) {
       ConnectionAdaptor.subscribe(channels[key]);
     }
   }
 };
-
 var handleEventProlongedState = () => {
   // console.log("LViS::handleEventProlongedState");
   var channels = lvisEvent.getChannels();
-  Factories.setChannels(channels); // subscribe to all channels
+  Factories.setChannels(channels);
 
+  // subscribe to all channels
   for (var key in channels) {
     if ({}.hasOwnProperty.call(channels, key)) {
       ConnectionAdaptor.subscribe(channels[key]);
     }
   }
 };
-
 var handleEventFinishedState = () => {
   // console.log("LViS::handleEventFinishedState");
-  var channels = lvisEvent.getChannels(); // unsubscribe from all channels
+  var channels = lvisEvent.getChannels();
 
+  // unsubscribe from all channels
   for (var key in channels) {
     if ({}.hasOwnProperty.call(channels, key)) {
       ConnectionAdaptor.unsubscribe(channels[key]);
     }
   }
 };
-
 var handleEnmasseState = function handleEnmasseState() {
   var state = arguments.length <= 0 ? undefined : arguments[0];
-
   switch (state) {
     case Enmasse.STATE_CONNECTED:
       {
         var time = arguments.length <= 1 ? undefined : arguments[1];
         LViSDate.setTime(time);
         ConnectionAdaptor.subscribe(channel);
-
         if (lvisEvent && lvisEvent.isReady()) {
           lvisEvent.loadHistory(getHost(), true).always(handleEventState);
         } else {
           handleEventState();
         }
-
         break;
       }
   }
 };
-
 var handleEnmasseReady = () => {
   // console.log("API::handleEnmasseReady");
   enmasseReady.resolve();
   Enmasse.connect();
 };
-
 var handleEnmasseError = () => {
   // console.log("API::handleEnmasseError");
   enmasseReady.reject();
 };
-
 var handleListingsReady = () => {
   embedAssets().done(() => assetsReady.resolve()).fail(() => assetsReady.reject());
 };
-
 var handleSyncDelayChange = () => {
   LViS.resetEvent();
 };
-
 var initWithConfig = function initWithConfig() {
   var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var UUIDSchema = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
   var hostSchema = /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9-]*[A-Za-z0-9])$/i;
-
   if (typeof config.host === 'undefined' || config.host === null) {
     LViS.trigger(LViS.ON_ERROR);
     console.error('Host is not set');
     return;
   }
-
   if (typeof config.project === 'undefined' || config.project === null) {
     LViS.trigger(LViS.ON_ERROR);
     console.error('Project UUID is not set');
     return;
   }
-
   if (!UUIDSchema.test(config.project)) {
     LViS.trigger(LViS.ON_ERROR);
     console.error('Project UUID has incorrect format');
     return;
   }
-
   if (!hostSchema.test(config.host)) {
     LViS.trigger(LViS.ON_ERROR);
     console.error('Host has incorrect format');
     return;
   }
-
   if (initialised) {
     console.warn('Attempt to initialise library when it was already initialised');
     return;
   }
-
   if (typeof config.forceSecure === 'boolean') {
     forceSecure = config.forceSecure;
   }
+  channel = "".concat(CHANNEL_CONTROL, "-").concat(config.project);
 
-  channel = "".concat(CHANNEL_CONTROL, "-").concat(config.project); // remove leading //, http:// or https://
-
+  // remove leading //, http:// or https://
   host = config.host.replace(/^(.*:)?(\/+)?/gi, '');
   Enmasse.bind(Enmasse.ON_READY, handleEnmasseReady);
   Enmasse.bind(Enmasse.ON_ERROR, handleEnmasseError);
@@ -3419,29 +2853,26 @@ var initWithConfig = function initWithConfig() {
   });
   initialised = true;
 };
+
 /*
  * Public methods
  */
 
-
 var getHost = () => {
   var protocol = forceSecure || document.location.protocol.indexOf('https') === 0 ? 'https' : 'http';
   return "".concat(protocol, "://").concat(host);
 };
-
 var getAssets = function getAssets() {
   return Listings.getAssets(...arguments);
 };
-
 var getEvent = () => lvisEvent;
-
 var setEvent = newEvent => {
   // console.log("LVIS::setEvent", newEvent);
+
   // new event mustn't be set if it was already
   if (lvisEvent === newEvent) {
     return;
   }
-
   unsetEvent();
   lvisEvent = newEvent;
   newEvent.loadHistory(getHost()).always(() => {
@@ -3453,72 +2884,64 @@ var setEvent = newEvent => {
     handleEventState();
   });
 };
-
 var unsetEvent = () => {
   if (lvisEvent === null) {
     return;
   }
+  var channels = lvisEvent.getChannels();
 
-  var channels = lvisEvent.getChannels(); // unsubscribe from all channels
-
+  // unsubscribe from all channels
   for (var key in channels) {
     if ({}.hasOwnProperty.call(channels, key)) {
       ConnectionAdaptor.unsubscribe(channels[key]);
     }
   }
-
   lvisEvent.unbind(Event.ON_SUBSTATE, handleEventState);
   lvisEvent.unbind(Event.ON_EOC, handleEventEOC);
   lvisEvent.markAsNotReady();
   lvisEvent = null;
 };
-
 var resetEvent = () => {
   ConnectionAdaptor.unsubscribe(channel);
   ConnectionAdaptor.subscribe(channel);
-
   if (lvisEvent === null) {
     return;
   }
+  var channels = lvisEvent.getChannels();
 
-  var channels = lvisEvent.getChannels(); // unsubscribe from events channels
-
+  // unsubscribe from events channels
   for (var key in channels) {
     if ({}.hasOwnProperty.call(channels, key)) {
       ConnectionAdaptor.unsubscribe(channels[key]);
       ConnectionAdaptor.subscribe(channels[key]);
     }
   }
-
   lvisEvent.markAsNotReady();
 };
-
 var init = function init() {
   var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var initDone = new Deferred();
-
   if (config.host && config.project) {
     initWithConfig(config);
     return initDone.resolve();
-  } // Load miccfg.json file for initialisation config.
-
+  }
 
+  // Load miccfg.json file for initialisation config.
   fetch(MIC_CONFIG_FILE).then(response => response.json()).then(data => {
     if (data.project) {
       config.project = data.project;
     }
-
     if (data.static_host) {
       config.host = data.static_host;
     }
-  }).catch(() => {// Ignore loading error, as the file only available when custom URL is set.
+  }).catch(() => {
+    // Ignore loading error, as the file only available when custom URL is set.
   }).finally(() => {
     initWithConfig(config);
     initDone.resolve();
   });
   return initDone;
 };
-
 LViS.getHost = getHost;
 LViS.getAssets = getAssets;
 LViS.getEvent = getEvent;