repo: janusweb
action: commit
revision: 
path_from: 
revision_from: 6730e64b1bf3c1dc212e40ec85eb450bc6a6de35:
path_to: 
revision_to: 

commit 6730e64b1bf3c1dc212e40ec85eb450bc6a6de35
Author: James Baicoianu 
Date:   Fri Jun 12 23:38:46 2020 -0700

    Disable default player label

diff --git a/media/assets/webui/apps/comms/external/naf-janus-adapter.js b/media/assets/webui/apps/comms/external/naf-janus-adapter.js
new file mode 100644
index 0000000000000000000000000000000000000000..f72c8e9822c3b3ef5b0209e021f94ee9976f486a
--- /dev/null
+++ b/media/assets/webui/apps/comms/external/naf-janus-adapter.js
@@ -0,0 +1,2975 @@
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "./src/index.js");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "./node_modules/debug/src/browser.js":
+/*!*******************************************!*\
+  !*** ./node_modules/debug/src/browser.js ***!
+  \*******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(process) {/**
+ * This is the web browser implementation of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = __webpack_require__(/*! ./debug */ "./node_modules/debug/src/debug.js");
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = 'undefined' != typeof chrome
+               && 'undefined' != typeof chrome.storage
+                  ? chrome.storage.local
+                  : localstorage();
+
+/**
+ * Colors.
+ */
+
+exports.colors = [
+  '#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC',
+  '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF',
+  '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC',
+  '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF',
+  '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC',
+  '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033',
+  '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366',
+  '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933',
+  '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC',
+  '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF',
+  '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'
+];
+
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+
+function useColors() {
+  // NB: In an Electron preload script, document will be defined but not fully
+  // initialized. Since we know we're in Chrome, we'll just detect this case
+  // explicitly
+  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
+    return true;
+  }
+
+  // Internet Explorer and Edge do not support colors.
+  if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+    return false;
+  }
+
+  // is webkit? http://stackoverflow.com/a/16459606/376773
+  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+    // is firebug? http://stackoverflow.com/a/398120/376773
+    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+    // is firefox >= v31?
+    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+    // double check webkit in userAgent just in case we are in a worker
+    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+}
+
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+exports.formatters.j = function(v) {
+  try {
+    return JSON.stringify(v);
+  } catch (err) {
+    return '[UnexpectedJSONParseError]: ' + err.message;
+  }
+};
+
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+  var useColors = this.useColors;
+
+  args[0] = (useColors ? '%c' : '')
+    + this.namespace
+    + (useColors ? ' %c' : ' ')
+    + args[0]
+    + (useColors ? '%c ' : ' ')
+    + '+' + exports.humanize(this.diff);
+
+  if (!useColors) return;
+
+  var c = 'color: ' + this.color;
+  args.splice(1, 0, c, 'color: inherit')
+
+  // the final "%c" is somewhat tricky, because there could be other
+  // arguments passed either before or after the %c, so we need to
+  // figure out the correct index to insert the CSS into
+  var index = 0;
+  var lastC = 0;
+  args[0].replace(/%[a-zA-Z%]/g, function(match) {
+    if ('%%' === match) return;
+    index++;
+    if ('%c' === match) {
+      // we only are interested in the *last* %c
+      // (the user may have provided their own)
+      lastC = index;
+    }
+  });
+
+  args.splice(lastC, 0, c);
+}
+
+/**
+ * Invokes `console.log()` when available.
+ * No-op when `console.log` is not a "function".
+ *
+ * @api public
+ */
+
+function log() {
+  // this hackery is required for IE8/9, where
+  // the `console.log` function doesn't have 'apply'
+  return 'object' === typeof console
+    && console.log
+    && Function.prototype.apply.call(console.log, console, arguments);
+}
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+function save(namespaces) {
+  try {
+    if (null == namespaces) {
+      exports.storage.removeItem('debug');
+    } else {
+      exports.storage.debug = namespaces;
+    }
+  } catch(e) {}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+function load() {
+  var r;
+  try {
+    r = exports.storage.debug;
+  } catch(e) {}
+
+  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+  if (!r && typeof process !== 'undefined' && 'env' in process) {
+    r = process.env.DEBUG;
+  }
+
+  return r;
+}
+
+/**
+ * Enable namespaces listed in `localStorage.debug` initially.
+ */
+
+exports.enable(load());
+
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+function localstorage() {
+  try {
+    return window.localStorage;
+  } catch (e) {}
+}
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../process/browser.js */ "./node_modules/process/browser.js")))
+
+/***/ }),
+
+/***/ "./node_modules/debug/src/debug.js":
+/*!*****************************************!*\
+  !*** ./node_modules/debug/src/debug.js ***!
+  \*****************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
+exports.coerce = coerce;
+exports.disable = disable;
+exports.enable = enable;
+exports.enabled = enabled;
+exports.humanize = __webpack_require__(/*! ms */ "./node_modules/ms/index.js");
+
+/**
+ * Active `debug` instances.
+ */
+exports.instances = [];
+
+/**
+ * The currently active debug mode names, and names to skip.
+ */
+
+exports.names = [];
+exports.skips = [];
+
+/**
+ * Map of special "%n" handling functions, for the debug "format" argument.
+ *
+ * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+ */
+
+exports.formatters = {};
+
+/**
+ * Select a color.
+ * @param {String} namespace
+ * @return {Number}
+ * @api private
+ */
+
+function selectColor(namespace) {
+  var hash = 0, i;
+
+  for (i in namespace) {
+    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
+    hash |= 0; // Convert to 32bit integer
+  }
+
+  return exports.colors[Math.abs(hash) % exports.colors.length];
+}
+
+/**
+ * Create a debugger with the given `namespace`.
+ *
+ * @param {String} namespace
+ * @return {Function}
+ * @api public
+ */
+
+function createDebug(namespace) {
+
+  var prevTime;
+
+  function debug() {
+    // disabled?
+    if (!debug.enabled) return;
+
+    var self = debug;
+
+    // set `diff` timestamp
+    var curr = +new Date();
+    var ms = curr - (prevTime || curr);
+    self.diff = ms;
+    self.prev = prevTime;
+    self.curr = curr;
+    prevTime = curr;
+
+    // turn the `arguments` into a proper Array
+    var args = new Array(arguments.length);
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
+    }
+
+    args[0] = exports.coerce(args[0]);
+
+    if ('string' !== typeof args[0]) {
+      // anything else let's inspect with %O
+      args.unshift('%O');
+    }
+
+    // apply any `formatters` transformations
+    var index = 0;
+    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+      // if we encounter an escaped % then don't increase the array index
+      if (match === '%%') return match;
+      index++;
+      var formatter = exports.formatters[format];
+      if ('function' === typeof formatter) {
+        var val = args[index];
+        match = formatter.call(self, val);
+
+        // now we need to remove `args[index]` since it's inlined in the `format`
+        args.splice(index, 1);
+        index--;
+      }
+      return match;
+    });
+
+    // apply env-specific formatting (colors, etc.)
+    exports.formatArgs.call(self, args);
+
+    var logFn = debug.log || exports.log || console.log.bind(console);
+    logFn.apply(self, args);
+  }
+
+  debug.namespace = namespace;
+  debug.enabled = exports.enabled(namespace);
+  debug.useColors = exports.useColors();
+  debug.color = selectColor(namespace);
+  debug.destroy = destroy;
+
+  // env-specific initialization logic for debug instances
+  if ('function' === typeof exports.init) {
+    exports.init(debug);
+  }
+
+  exports.instances.push(debug);
+
+  return debug;
+}
+
+function destroy () {
+  var index = exports.instances.indexOf(this);
+  if (index !== -1) {
+    exports.instances.splice(index, 1);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Enables a debug mode by namespaces. This can include modes
+ * separated by a colon and wildcards.
+ *
+ * @param {String} namespaces
+ * @api public
+ */
+
+function enable(namespaces) {
+  exports.save(namespaces);
+
+  exports.names = [];
+  exports.skips = [];
+
+  var i;
+  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+  var len = split.length;
+
+  for (i = 0; i < len; i++) {
+    if (!split[i]) continue; // ignore empty strings
+    namespaces = split[i].replace(/\*/g, '.*?');
+    if (namespaces[0] === '-') {
+      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+    } else {
+      exports.names.push(new RegExp('^' + namespaces + '$'));
+    }
+  }
+
+  for (i = 0; i < exports.instances.length; i++) {
+    var instance = exports.instances[i];
+    instance.enabled = exports.enabled(instance.namespace);
+  }
+}
+
+/**
+ * Disable debug output.
+ *
+ * @api public
+ */
+
+function disable() {
+  exports.enable('');
+}
+
+/**
+ * Returns true if the given mode name is enabled, false otherwise.
+ *
+ * @param {String} name
+ * @return {Boolean}
+ * @api public
+ */
+
+function enabled(name) {
+  if (name[name.length - 1] === '*') {
+    return true;
+  }
+  var i, len;
+  for (i = 0, len = exports.skips.length; i < len; i++) {
+    if (exports.skips[i].test(name)) {
+      return false;
+    }
+  }
+  for (i = 0, len = exports.names.length; i < len; i++) {
+    if (exports.names[i].test(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Coerce `val`.
+ *
+ * @param {Mixed} val
+ * @return {Mixed}
+ * @api private
+ */
+
+function coerce(val) {
+  if (val instanceof Error) return val.stack || val.message;
+  return val;
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/minijanus/minijanus.js":
+/*!*********************************************!*\
+  !*** ./node_modules/minijanus/minijanus.js ***!
+  \*********************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+/**
+ * Represents a handle to a single Janus plugin on a Janus session. Each WebRTC connection to the Janus server will be
+ * associated with a single handle. Once attached to the server, this handle will be given a unique ID which should be
+ * used to associate it with future signalling messages.
+ *
+ * See https://janus.conf.meetecho.com/docs/rest.html#handles.
+ **/
+function JanusPluginHandle(session) {
+  this.session = session;
+  this.id = undefined;
+}
+
+/** Attaches this handle to the Janus server and sets its ID. **/
+JanusPluginHandle.prototype.attach = function(plugin) {
+  var payload = { plugin: plugin, "force-bundle": true, "force-rtcp-mux": true };
+  return this.session.send("attach", payload).then(resp => {
+    this.id = resp.data.id;
+    return resp;
+  });
+};
+
+/** Detaches this handle. **/
+JanusPluginHandle.prototype.detach = function() {
+  return this.send("detach");
+};
+
+/** Registers a callback to be fired upon the reception of any incoming Janus signals for this plugin handle with the
+ * `janus` attribute equal to `ev`.
+ **/
+JanusPluginHandle.prototype.on = function(ev, callback) {
+  return this.session.on(ev, signal => {
+    if (signal.sender == this.id) {
+      callback(signal);
+    }
+  });
+};
+
+/**
+ * Sends a signal associated with this handle. Signals should be JSON-serializable objects. Returns a promise that will
+ * be resolved or rejected when a response to this signal is received, or when no response is received within the
+ * session timeout.
+ **/
+JanusPluginHandle.prototype.send = function(type, signal) {
+  return this.session.send(type, Object.assign({ handle_id: this.id }, signal));
+};
+
+/** Sends a plugin-specific message associated with this handle. **/
+JanusPluginHandle.prototype.sendMessage = function(body) {
+  return this.send("message", { body: body });
+};
+
+/** Sends a JSEP offer or answer associated with this handle. **/
+JanusPluginHandle.prototype.sendJsep = function(jsep) {
+  return this.send("message", { body: {}, jsep: jsep });
+};
+
+/** Sends an ICE trickle candidate associated with this handle. **/
+JanusPluginHandle.prototype.sendTrickle = function(candidate) {
+  return this.send("trickle", { candidate: candidate });
+};
+
+/**
+ * Represents a Janus session -- a Janus context from within which you can open multiple handles and connections. Once
+ * created, this session will be given a unique ID which should be used to associate it with future signalling messages.
+ *
+ * See https://janus.conf.meetecho.com/docs/rest.html#sessions.
+ **/
+function JanusSession(output, options) {
+  this.output = output;
+  this.id = undefined;
+  this.nextTxId = 0;
+  this.txns = {};
+  this.eventHandlers = {};
+  this.options = Object.assign({
+    verbose: false,
+    timeoutMs: 10000,
+    keepaliveMs: 30000
+  }, options);
+}
+
+/** Creates this session on the Janus server and sets its ID. **/
+JanusSession.prototype.create = function() {
+  return this.send("create").then(resp => {
+    this.id = resp.data.id;
+    return resp;
+  });
+};
+
+/**
+ * Destroys this session. Note that upon destruction, Janus will also close the signalling transport (if applicable) and
+ * any open WebRTC connections.
+ **/
+JanusSession.prototype.destroy = function() {
+  return this.send("destroy").then((resp) => {
+    this.dispose();
+    return resp;
+  });
+};
+
+/**
+ * Disposes of this session in a way such that no further incoming signalling messages will be processed.
+ * Outstanding transactions will be rejected.
+ **/
+JanusSession.prototype.dispose = function() {
+  this._killKeepalive();
+  this.eventHandlers = {};
+  for (var txId in this.txns) {
+    if (this.txns.hasOwnProperty(txId)) {
+      var txn = this.txns[txId];
+      clearTimeout(txn.timeout);
+      txn.reject(new Error("Janus session was disposed."));
+      delete this.txns[txId];
+    }
+  }
+};
+
+/**
+ * Whether this signal represents an error, and the associated promise (if any) should be rejected.
+ * Users should override this to handle any custom plugin-specific error conventions.
+ **/
+JanusSession.prototype.isError = function(signal) {
+  return signal.janus === "error";
+};
+
+/** Registers a callback to be fired upon the reception of any incoming Janus signals for this session with the
+ * `janus` attribute equal to `ev`.
+ **/
+JanusSession.prototype.on = function(ev, callback) {
+  var handlers = this.eventHandlers[ev];
+  if (handlers == null) {
+    handlers = this.eventHandlers[ev] = [];
+  }
+  handlers.push(callback);
+};
+
+/**
+ * Callback for receiving JSON signalling messages pertinent to this session. If the signals are responses to previously
+ * sent signals, the promises for the outgoing signals will be resolved or rejected appropriately with this signal as an
+ * argument.
+ *
+ * External callers should call this function every time a new signal arrives on the transport; for example, in a
+ * WebSocket's `message` event, or when a new datum shows up in an HTTP long-polling response.
+ **/
+JanusSession.prototype.receive = function(signal) {
+  if (this.options.verbose) {
+    this._logIncoming(signal);
+  }
+  if (signal.session_id != this.id) {
+    console.warn("Incorrect session ID received in Janus signalling message: was " + signal.session_id + ", expected " + this.id + ".");
+  }
+
+  var responseType = signal.janus;
+  var handlers = this.eventHandlers[responseType];
+  if (handlers != null) {
+    for (var i = 0; i < handlers.length; i++) {
+      handlers[i](signal);
+    }
+  }
+
+  if (signal.transaction != null) {
+    var txn = this.txns[signal.transaction];
+    if (txn == null) {
+      // this is a response to a transaction that wasn't caused via JanusSession.send, or a plugin replied twice to a
+      // single request, or the session was disposed, or something else that isn't under our purview; that's fine
+      return;
+    }
+
+    if (responseType === "ack" && txn.type == "message") {
+      // this is an ack of an asynchronously-processed plugin request, we should wait to resolve the promise until the
+      // actual response comes in
+      return;
+    }
+
+    clearTimeout(txn.timeout);
+
+    delete this.txns[signal.transaction];
+    (this.isError(signal) ? txn.reject : txn.resolve)(signal);
+  }
+};
+
+/**
+ * Sends a signal associated with this session, beginning a new transaction. Returns a promise that will be resolved or
+ * rejected when a response is received in the same transaction, or when no response is received within the session
+ * timeout.
+ **/
+JanusSession.prototype.send = function(type, signal) {
+  signal = Object.assign({ transaction: (this.nextTxId++).toString() }, signal);
+  return new Promise((resolve, reject) => {
+    var timeout = null;
+    if (this.options.timeoutMs) {
+      timeout = setTimeout(() => {
+        delete this.txns[signal.transaction];
+        reject(new Error("Signalling transaction with txid " + signal.transaction + " timed out."));
+      }, this.options.timeoutMs);
+    }
+    this.txns[signal.transaction] = { resolve: resolve, reject: reject, timeout: timeout, type: type };
+    this._transmit(type, signal);
+  });
+};
+
+JanusSession.prototype._transmit = function(type, signal) {
+  signal = Object.assign({ janus: type }, signal);
+
+  if (this.id != null) { // this.id is undefined in the special case when we're sending the session create message
+    signal = Object.assign({ session_id: this.id }, signal);
+  }
+
+  if (this.options.verbose) {
+    this._logOutgoing(signal);
+  }
+
+  this.output(JSON.stringify(signal));
+  this._resetKeepalive();
+};
+
+JanusSession.prototype._logOutgoing = function(signal) {
+  var kind = signal.janus;
+  if (kind === "message" && signal.jsep) {
+    kind = signal.jsep.type;
+  }
+  var message = "> Outgoing Janus " + (kind || "signal") + " (#" + signal.transaction + "): ";
+  console.debug("%c" + message, "color: #040", signal);
+};
+
+JanusSession.prototype._logIncoming = function(signal) {
+  var kind = signal.janus;
+  var message = signal.transaction ?
+      "< Incoming Janus " + (kind || "signal") + " (#" + signal.transaction + "): " :
+      "< Incoming Janus " + (kind || "signal") + ": ";
+  console.debug("%c" + message, "color: #004", signal);
+};
+
+JanusSession.prototype._sendKeepalive = function() {
+  return this.send("keepalive");
+};
+
+JanusSession.prototype._killKeepalive = function() {
+  clearTimeout(this.keepaliveTimeout);
+};
+
+JanusSession.prototype._resetKeepalive = function() {
+  this._killKeepalive();
+  if (this.options.keepaliveMs) {
+    this.keepaliveTimeout = setTimeout(() => {
+      this._sendKeepalive().catch(e => console.error("Error received from keepalive: ", e));
+    }, this.options.keepaliveMs);
+  }
+};
+
+module.exports = {
+  JanusPluginHandle,
+  JanusSession
+};
+
+
+/***/ }),
+
+/***/ "./node_modules/ms/index.js":
+/*!**********************************!*\
+  !*** ./node_modules/ms/index.js ***!
+  \**********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isNaN(val) === false) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  if (ms >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (ms >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (ms >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (ms >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  return plural(ms, d, 'day') ||
+    plural(ms, h, 'hour') ||
+    plural(ms, m, 'minute') ||
+    plural(ms, s, 'second') ||
+    ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, n, name) {
+  if (ms < n) {
+    return;
+  }
+  if (ms < n * 1.5) {
+    return Math.floor(ms / n) + ' ' + name;
+  }
+  return Math.ceil(ms / n) + ' ' + name + 's';
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/process/browser.js":
+/*!*****************************************!*\
+  !*** ./node_modules/process/browser.js ***!
+  \*****************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+
+/***/ }),
+
+/***/ "./node_modules/sdp/sdp.js":
+/*!*********************************!*\
+  !*** ./node_modules/sdp/sdp.js ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+ /* eslint-env node */
+
+
+// SDP helpers.
+var SDPUtils = {};
+
+// Generate an alphanumeric identifier for cname or mids.
+// TODO: use UUIDs instead? https://gist.github.com/jed/982883
+SDPUtils.generateIdentifier = function() {
+  return Math.random().toString(36).substr(2, 10);
+};
+
+// The RTCP CNAME used by all peerconnections from the same JS.
+SDPUtils.localCName = SDPUtils.generateIdentifier();
+
+// Splits SDP into lines, dealing with both CRLF and LF.
+SDPUtils.splitLines = function(blob) {
+  return blob.trim().split('\n').map(function(line) {
+    return line.trim();
+  });
+};
+// Splits SDP into sessionpart and mediasections. Ensures CRLF.
+SDPUtils.splitSections = function(blob) {
+  var parts = blob.split('\nm=');
+  return parts.map(function(part, index) {
+    return (index > 0 ? 'm=' + part : part).trim() + '\r\n';
+  });
+};
+
+// returns the session description.
+SDPUtils.getDescription = function(blob) {
+  var sections = SDPUtils.splitSections(blob);
+  return sections && sections[0];
+};
+
+// returns the individual media sections.
+SDPUtils.getMediaSections = function(blob) {
+  var sections = SDPUtils.splitSections(blob);
+  sections.shift();
+  return sections;
+};
+
+// Returns lines that start with a certain prefix.
+SDPUtils.matchPrefix = function(blob, prefix) {
+  return SDPUtils.splitLines(blob).filter(function(line) {
+    return line.indexOf(prefix) === 0;
+  });
+};
+
+// Parses an ICE candidate line. Sample input:
+// candidate:702786350 2 udp 41819902 8.8.8.8 60769 typ relay raddr 8.8.8.8
+// rport 55996"
+SDPUtils.parseCandidate = function(line) {
+  var parts;
+  // Parse both variants.
+  if (line.indexOf('a=candidate:') === 0) {
+    parts = line.substring(12).split(' ');
+  } else {
+    parts = line.substring(10).split(' ');
+  }
+
+  var candidate = {
+    foundation: parts[0],
+    component: parseInt(parts[1], 10),
+    protocol: parts[2].toLowerCase(),
+    priority: parseInt(parts[3], 10),
+    ip: parts[4],
+    port: parseInt(parts[5], 10),
+    // skip parts[6] == 'typ'
+    type: parts[7]
+  };
+
+  for (var i = 8; i < parts.length; i += 2) {
+    switch (parts[i]) {
+      case 'raddr':
+        candidate.relatedAddress = parts[i + 1];
+        break;
+      case 'rport':
+        candidate.relatedPort = parseInt(parts[i + 1], 10);
+        break;
+      case 'tcptype':
+        candidate.tcpType = parts[i + 1];
+        break;
+      case 'ufrag':
+        candidate.ufrag = parts[i + 1]; // for backward compability.
+        candidate.usernameFragment = parts[i + 1];
+        break;
+      default: // extension handling, in particular ufrag
+        candidate[parts[i]] = parts[i + 1];
+        break;
+    }
+  }
+  return candidate;
+};
+
+// Translates a candidate object into SDP candidate attribute.
+SDPUtils.writeCandidate = function(candidate) {
+  var sdp = [];
+  sdp.push(candidate.foundation);
+  sdp.push(candidate.component);
+  sdp.push(candidate.protocol.toUpperCase());
+  sdp.push(candidate.priority);
+  sdp.push(candidate.ip);
+  sdp.push(candidate.port);
+
+  var type = candidate.type;
+  sdp.push('typ');
+  sdp.push(type);
+  if (type !== 'host' && candidate.relatedAddress &&
+      candidate.relatedPort) {
+    sdp.push('raddr');
+    sdp.push(candidate.relatedAddress);
+    sdp.push('rport');
+    sdp.push(candidate.relatedPort);
+  }
+  if (candidate.tcpType && candidate.protocol.toLowerCase() === 'tcp') {
+    sdp.push('tcptype');
+    sdp.push(candidate.tcpType);
+  }
+  if (candidate.usernameFragment || candidate.ufrag) {
+    sdp.push('ufrag');
+    sdp.push(candidate.usernameFragment || candidate.ufrag);
+  }
+  return 'candidate:' + sdp.join(' ');
+};
+
+// Parses an ice-options line, returns an array of option tags.
+// a=ice-options:foo bar
+SDPUtils.parseIceOptions = function(line) {
+  return line.substr(14).split(' ');
+}
+
+// Parses an rtpmap line, returns RTCRtpCoddecParameters. Sample input:
+// a=rtpmap:111 opus/48000/2
+SDPUtils.parseRtpMap = function(line) {
+  var parts = line.substr(9).split(' ');
+  var parsed = {
+    payloadType: parseInt(parts.shift(), 10) // was: id
+  };
+
+  parts = parts[0].split('/');
+
+  parsed.name = parts[0];
+  parsed.clockRate = parseInt(parts[1], 10); // was: clockrate
+  parsed.channels = parts.length === 3 ? parseInt(parts[2], 10) : 1;
+  // legacy alias, got renamed back to channels in ORTC.
+  parsed.numChannels = parsed.channels;
+  return parsed;
+};
+
+// Generate an a=rtpmap line from RTCRtpCodecCapability or
+// RTCRtpCodecParameters.
+SDPUtils.writeRtpMap = function(codec) {
+  var pt = codec.payloadType;
+  if (codec.preferredPayloadType !== undefined) {
+    pt = codec.preferredPayloadType;
+  }
+  var channels = codec.channels || codec.numChannels || 1;
+  return 'a=rtpmap:' + pt + ' ' + codec.name + '/' + codec.clockRate +
+      (channels !== 1 ? '/' + channels : '') + '\r\n';
+};
+
+// Parses an a=extmap line (headerextension from RFC 5285). Sample input:
+// a=extmap:2 urn:ietf:params:rtp-hdrext:toffset
+// a=extmap:2/sendonly urn:ietf:params:rtp-hdrext:toffset
+SDPUtils.parseExtmap = function(line) {
+  var parts = line.substr(9).split(' ');
+  return {
+    id: parseInt(parts[0], 10),
+    direction: parts[0].indexOf('/') > 0 ? parts[0].split('/')[1] : 'sendrecv',
+    uri: parts[1]
+  };
+};
+
+// Generates a=extmap line from RTCRtpHeaderExtensionParameters or
+// RTCRtpHeaderExtension.
+SDPUtils.writeExtmap = function(headerExtension) {
+  return 'a=extmap:' + (headerExtension.id || headerExtension.preferredId) +
+      (headerExtension.direction && headerExtension.direction !== 'sendrecv'
+          ? '/' + headerExtension.direction
+          : '') +
+      ' ' + headerExtension.uri + '\r\n';
+};
+
+// Parses an ftmp line, returns dictionary. Sample input:
+// a=fmtp:96 vbr=on;cng=on
+// Also deals with vbr=on; cng=on
+SDPUtils.parseFmtp = function(line) {
+  var parsed = {};
+  var kv;
+  var parts = line.substr(line.indexOf(' ') + 1).split(';');
+  for (var j = 0; j < parts.length; j++) {
+    kv = parts[j].trim().split('=');
+    parsed[kv[0].trim()] = kv[1];
+  }
+  return parsed;
+};
+
+// Generates an a=ftmp line from RTCRtpCodecCapability or RTCRtpCodecParameters.
+SDPUtils.writeFmtp = function(codec) {
+  var line = '';
+  var pt = codec.payloadType;
+  if (codec.preferredPayloadType !== undefined) {
+    pt = codec.preferredPayloadType;
+  }
+  if (codec.parameters && Object.keys(codec.parameters).length) {
+    var params = [];
+    Object.keys(codec.parameters).forEach(function(param) {
+      if (codec.parameters[param]) {
+        params.push(param + '=' + codec.parameters[param]);
+      } else {
+        params.push(param);
+      }
+    });
+    line += 'a=fmtp:' + pt + ' ' + params.join(';') + '\r\n';
+  }
+  return line;
+};
+
+// Parses an rtcp-fb line, returns RTCPRtcpFeedback object. Sample input:
+// a=rtcp-fb:98 nack rpsi
+SDPUtils.parseRtcpFb = function(line) {
+  var parts = line.substr(line.indexOf(' ') + 1).split(' ');
+  return {
+    type: parts.shift(),
+    parameter: parts.join(' ')
+  };
+};
+// Generate a=rtcp-fb lines from RTCRtpCodecCapability or RTCRtpCodecParameters.
+SDPUtils.writeRtcpFb = function(codec) {
+  var lines = '';
+  var pt = codec.payloadType;
+  if (codec.preferredPayloadType !== undefined) {
+    pt = codec.preferredPayloadType;
+  }
+  if (codec.rtcpFeedback && codec.rtcpFeedback.length) {
+    // FIXME: special handling for trr-int?
+    codec.rtcpFeedback.forEach(function(fb) {
+      lines += 'a=rtcp-fb:' + pt + ' ' + fb.type +
+      (fb.parameter && fb.parameter.length ? ' ' + fb.parameter : '') +
+          '\r\n';
+    });
+  }
+  return lines;
+};
+
+// Parses an RFC 5576 ssrc media attribute. Sample input:
+// a=ssrc:3735928559 cname:something
+SDPUtils.parseSsrcMedia = function(line) {
+  var sp = line.indexOf(' ');
+  var parts = {
+    ssrc: parseInt(line.substr(7, sp - 7), 10)
+  };
+  var colon = line.indexOf(':', sp);
+  if (colon > -1) {
+    parts.attribute = line.substr(sp + 1, colon - sp - 1);
+    parts.value = line.substr(colon + 1);
+  } else {
+    parts.attribute = line.substr(sp + 1);
+  }
+  return parts;
+};
+
+// Extracts the MID (RFC 5888) from a media section.
+// returns the MID or undefined if no mid line was found.
+SDPUtils.getMid = function(mediaSection) {
+  var mid = SDPUtils.matchPrefix(mediaSection, 'a=mid:')[0];
+  if (mid) {
+    return mid.substr(6);
+  }
+}
+
+SDPUtils.parseFingerprint = function(line) {
+  var parts = line.substr(14).split(' ');
+  return {
+    algorithm: parts[0].toLowerCase(), // algorithm is case-sensitive in Edge.
+    value: parts[1]
+  };
+};
+
+// Extracts DTLS parameters from SDP media section or sessionpart.
+// FIXME: for consistency with other functions this should only
+//   get the fingerprint line as input. See also getIceParameters.
+SDPUtils.getDtlsParameters = function(mediaSection, sessionpart) {
+  var lines = SDPUtils.matchPrefix(mediaSection + sessionpart,
+      'a=fingerprint:');
+  // Note: a=setup line is ignored since we use the 'auto' role.
+  // Note2: 'algorithm' is not case sensitive except in Edge.
+  return {
+    role: 'auto',
+    fingerprints: lines.map(SDPUtils.parseFingerprint)
+  };
+};
+
+// Serializes DTLS parameters to SDP.
+SDPUtils.writeDtlsParameters = function(params, setupType) {
+  var sdp = 'a=setup:' + setupType + '\r\n';
+  params.fingerprints.forEach(function(fp) {
+    sdp += 'a=fingerprint:' + fp.algorithm + ' ' + fp.value + '\r\n';
+  });
+  return sdp;
+};
+// Parses ICE information from SDP media section or sessionpart.
+// FIXME: for consistency with other functions this should only
+//   get the ice-ufrag and ice-pwd lines as input.
+SDPUtils.getIceParameters = function(mediaSection, sessionpart) {
+  var lines = SDPUtils.splitLines(mediaSection);
+  // Search in session part, too.
+  lines = lines.concat(SDPUtils.splitLines(sessionpart));
+  var iceParameters = {
+    usernameFragment: lines.filter(function(line) {
+      return line.indexOf('a=ice-ufrag:') === 0;
+    })[0].substr(12),
+    password: lines.filter(function(line) {
+      return line.indexOf('a=ice-pwd:') === 0;
+    })[0].substr(10)
+  };
+  return iceParameters;
+};
+
+// Serializes ICE parameters to SDP.
+SDPUtils.writeIceParameters = function(params) {
+  return 'a=ice-ufrag:' + params.usernameFragment + '\r\n' +
+      'a=ice-pwd:' + params.password + '\r\n';
+};
+
+// Parses the SDP media section and returns RTCRtpParameters.
+SDPUtils.parseRtpParameters = function(mediaSection) {
+  var description = {
+    codecs: [],
+    headerExtensions: [],
+    fecMechanisms: [],
+    rtcp: []
+  };
+  var lines = SDPUtils.splitLines(mediaSection);
+  var mline = lines[0].split(' ');
+  for (var i = 3; i < mline.length; i++) { // find all codecs from mline[3..]
+    var pt = mline[i];
+    var rtpmapline = SDPUtils.matchPrefix(
+        mediaSection, 'a=rtpmap:' + pt + ' ')[0];
+    if (rtpmapline) {
+      var codec = SDPUtils.parseRtpMap(rtpmapline);
+      var fmtps = SDPUtils.matchPrefix(
+          mediaSection, 'a=fmtp:' + pt + ' ');
+      // Only the first a=fmtp: is considered.
+      codec.parameters = fmtps.length ? SDPUtils.parseFmtp(fmtps[0]) : {};
+      codec.rtcpFeedback = SDPUtils.matchPrefix(
+          mediaSection, 'a=rtcp-fb:' + pt + ' ')
+        .map(SDPUtils.parseRtcpFb);
+      description.codecs.push(codec);
+      // parse FEC mechanisms from rtpmap lines.
+      switch (codec.name.toUpperCase()) {
+        case 'RED':
+        case 'ULPFEC':
+          description.fecMechanisms.push(codec.name.toUpperCase());
+          break;
+        default: // only RED and ULPFEC are recognized as FEC mechanisms.
+          break;
+      }
+    }
+  }
+  SDPUtils.matchPrefix(mediaSection, 'a=extmap:').forEach(function(line) {
+    description.headerExtensions.push(SDPUtils.parseExtmap(line));
+  });
+  // FIXME: parse rtcp.
+  return description;
+};
+
+// Generates parts of the SDP media section describing the capabilities /
+// parameters.
+SDPUtils.writeRtpDescription = function(kind, caps) {
+  var sdp = '';
+
+  // Build the mline.
+  sdp += 'm=' + kind + ' ';
+  sdp += caps.codecs.length > 0 ? '9' : '0'; // reject if no codecs.
+  sdp += ' UDP/TLS/RTP/SAVPF ';
+  sdp += caps.codecs.map(function(codec) {
+    if (codec.preferredPayloadType !== undefined) {
+      return codec.preferredPayloadType;
+    }
+    return codec.payloadType;
+  }).join(' ') + '\r\n';
+
+  sdp += 'c=IN IP4 0.0.0.0\r\n';
+  sdp += 'a=rtcp:9 IN IP4 0.0.0.0\r\n';
+
+  // Add a=rtpmap lines for each codec. Also fmtp and rtcp-fb.
+  caps.codecs.forEach(function(codec) {
+    sdp += SDPUtils.writeRtpMap(codec);
+    sdp += SDPUtils.writeFmtp(codec);
+    sdp += SDPUtils.writeRtcpFb(codec);
+  });
+  var maxptime = 0;
+  caps.codecs.forEach(function(codec) {
+    if (codec.maxptime > maxptime) {
+      maxptime = codec.maxptime;
+    }
+  });
+  if (maxptime > 0) {
+    sdp += 'a=maxptime:' + maxptime + '\r\n';
+  }
+  sdp += 'a=rtcp-mux\r\n';
+
+  if (caps.headerExtensions) {
+    caps.headerExtensions.forEach(function(extension) {
+      sdp += SDPUtils.writeExtmap(extension);
+    });
+  }
+  // FIXME: write fecMechanisms.
+  return sdp;
+};
+
+// Parses the SDP media section and returns an array of
+// RTCRtpEncodingParameters.
+SDPUtils.parseRtpEncodingParameters = function(mediaSection) {
+  var encodingParameters = [];
+  var description = SDPUtils.parseRtpParameters(mediaSection);
+  var hasRed = description.fecMechanisms.indexOf('RED') !== -1;
+  var hasUlpfec = description.fecMechanisms.indexOf('ULPFEC') !== -1;
+
+  // filter a=ssrc:... cname:, ignore PlanB-msid
+  var ssrcs = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+  .map(function(line) {
+    return SDPUtils.parseSsrcMedia(line);
+  })
+  .filter(function(parts) {
+    return parts.attribute === 'cname';
+  });
+  var primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;
+  var secondarySsrc;
+
+  var flows = SDPUtils.matchPrefix(mediaSection, 'a=ssrc-group:FID')
+  .map(function(line) {
+    var parts = line.substr(17).split(' ');
+    return parts.map(function(part) {
+      return parseInt(part, 10);
+    });
+  });
+  if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {
+    secondarySsrc = flows[0][1];
+  }
+
+  description.codecs.forEach(function(codec) {
+    if (codec.name.toUpperCase() === 'RTX' && codec.parameters.apt) {
+      var encParam = {
+        ssrc: primarySsrc,
+        codecPayloadType: parseInt(codec.parameters.apt, 10),
+      };
+      if (primarySsrc && secondarySsrc) {
+        encParam.rtx = {ssrc: secondarySsrc};
+      }
+      encodingParameters.push(encParam);
+      if (hasRed) {
+        encParam = JSON.parse(JSON.stringify(encParam));
+        encParam.fec = {
+          ssrc: secondarySsrc,
+          mechanism: hasUlpfec ? 'red+ulpfec' : 'red'
+        };
+        encodingParameters.push(encParam);
+      }
+    }
+  });
+  if (encodingParameters.length === 0 && primarySsrc) {
+    encodingParameters.push({
+      ssrc: primarySsrc
+    });
+  }
+
+  // we support both b=AS and b=TIAS but interpret AS as TIAS.
+  var bandwidth = SDPUtils.matchPrefix(mediaSection, 'b=');
+  if (bandwidth.length) {
+    if (bandwidth[0].indexOf('b=TIAS:') === 0) {
+      bandwidth = parseInt(bandwidth[0].substr(7), 10);
+    } else if (bandwidth[0].indexOf('b=AS:') === 0) {
+      // use formula from JSEP to convert b=AS to TIAS value.
+      bandwidth = parseInt(bandwidth[0].substr(5), 10) * 1000 * 0.95
+          - (50 * 40 * 8);
+    } else {
+      bandwidth = undefined;
+    }
+    encodingParameters.forEach(function(params) {
+      params.maxBitrate = bandwidth;
+    });
+  }
+  return encodingParameters;
+};
+
+// parses http://draft.ortc.org/#rtcrtcpparameters*
+SDPUtils.parseRtcpParameters = function(mediaSection) {
+  var rtcpParameters = {};
+
+  var cname;
+  // Gets the first SSRC. Note that with RTX there might be multiple
+  // SSRCs.
+  var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+      .map(function(line) {
+        return SDPUtils.parseSsrcMedia(line);
+      })
+      .filter(function(obj) {
+        return obj.attribute === 'cname';
+      })[0];
+  if (remoteSsrc) {
+    rtcpParameters.cname = remoteSsrc.value;
+    rtcpParameters.ssrc = remoteSsrc.ssrc;
+  }
+
+  // Edge uses the compound attribute instead of reducedSize
+  // compound is !reducedSize
+  var rsize = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-rsize');
+  rtcpParameters.reducedSize = rsize.length > 0;
+  rtcpParameters.compound = rsize.length === 0;
+
+  // parses the rtcp-mux attrіbute.
+  // Note that Edge does not support unmuxed RTCP.
+  var mux = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-mux');
+  rtcpParameters.mux = mux.length > 0;
+
+  return rtcpParameters;
+};
+
+// parses either a=msid: or a=ssrc:... msid lines and returns
+// the id of the MediaStream and MediaStreamTrack.
+SDPUtils.parseMsid = function(mediaSection) {
+  var parts;
+  var spec = SDPUtils.matchPrefix(mediaSection, 'a=msid:');
+  if (spec.length === 1) {
+    parts = spec[0].substr(7).split(' ');
+    return {stream: parts[0], track: parts[1]};
+  }
+  var planB = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+  .map(function(line) {
+    return SDPUtils.parseSsrcMedia(line);
+  })
+  .filter(function(parts) {
+    return parts.attribute === 'msid';
+  });
+  if (planB.length > 0) {
+    parts = planB[0].value.split(' ');
+    return {stream: parts[0], track: parts[1]};
+  }
+};
+
+// Generate a session ID for SDP.
+// https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-20#section-5.2.1
+// recommends using a cryptographically random +ve 64-bit value
+// but right now this should be acceptable and within the right range
+SDPUtils.generateSessionId = function() {
+  return Math.random().toString().substr(2, 21);
+};
+
+// Write boilder plate for start of SDP
+// sessId argument is optional - if not supplied it will
+// be generated randomly
+// sessVersion is optional and defaults to 2
+SDPUtils.writeSessionBoilerplate = function(sessId, sessVer) {
+  var sessionId;
+  var version = sessVer !== undefined ? sessVer : 2;
+  if (sessId) {
+    sessionId = sessId;
+  } else {
+    sessionId = SDPUtils.generateSessionId();
+  }
+  // FIXME: sess-id should be an NTP timestamp.
+  return 'v=0\r\n' +
+      'o=thisisadapterortc ' + sessionId + ' ' + version + ' IN IP4 127.0.0.1\r\n' +
+      's=-\r\n' +
+      't=0 0\r\n';
+};
+
+SDPUtils.writeMediaSection = function(transceiver, caps, type, stream) {
+  var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);
+
+  // Map ICE parameters (ufrag, pwd) to SDP.
+  sdp += SDPUtils.writeIceParameters(
+      transceiver.iceGatherer.getLocalParameters());
+
+  // Map DTLS parameters to SDP.
+  sdp += SDPUtils.writeDtlsParameters(
+      transceiver.dtlsTransport.getLocalParameters(),
+      type === 'offer' ? 'actpass' : 'active');
+
+  sdp += 'a=mid:' + transceiver.mid + '\r\n';
+
+  if (transceiver.direction) {
+    sdp += 'a=' + transceiver.direction + '\r\n';
+  } else if (transceiver.rtpSender && transceiver.rtpReceiver) {
+    sdp += 'a=sendrecv\r\n';
+  } else if (transceiver.rtpSender) {
+    sdp += 'a=sendonly\r\n';
+  } else if (transceiver.rtpReceiver) {
+    sdp += 'a=recvonly\r\n';
+  } else {
+    sdp += 'a=inactive\r\n';
+  }
+
+  if (transceiver.rtpSender) {
+    // spec.
+    var msid = 'msid:' + stream.id + ' ' +
+        transceiver.rtpSender.track.id + '\r\n';
+    sdp += 'a=' + msid;
+
+    // for Chrome.
+    sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+        ' ' + msid;
+    if (transceiver.sendEncodingParameters[0].rtx) {
+      sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+          ' ' + msid;
+      sdp += 'a=ssrc-group:FID ' +
+          transceiver.sendEncodingParameters[0].ssrc + ' ' +
+          transceiver.sendEncodingParameters[0].rtx.ssrc +
+          '\r\n';
+    }
+  }
+  // FIXME: this should be written by writeRtpDescription.
+  sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+      ' cname:' + SDPUtils.localCName + '\r\n';
+  if (transceiver.rtpSender && transceiver.sendEncodingParameters[0].rtx) {
+    sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+        ' cname:' + SDPUtils.localCName + '\r\n';
+  }
+  return sdp;
+};
+
+// Gets the direction from the mediaSection or the sessionpart.
+SDPUtils.getDirection = function(mediaSection, sessionpart) {
+  // Look for sendrecv, sendonly, recvonly, inactive, default to sendrecv.
+  var lines = SDPUtils.splitLines(mediaSection);
+  for (var i = 0; i < lines.length; i++) {
+    switch (lines[i]) {
+      case 'a=sendrecv':
+      case 'a=sendonly':
+      case 'a=recvonly':
+      case 'a=inactive':
+        return lines[i].substr(2);
+      default:
+        // FIXME: What should happen here?
+    }
+  }
+  if (sessionpart) {
+    return SDPUtils.getDirection(sessionpart);
+  }
+  return 'sendrecv';
+};
+
+SDPUtils.getKind = function(mediaSection) {
+  var lines = SDPUtils.splitLines(mediaSection);
+  var mline = lines[0].split(' ');
+  return mline[0].substr(2);
+};
+
+SDPUtils.isRejected = function(mediaSection) {
+  return mediaSection.split(' ', 2)[1] === '0';
+};
+
+SDPUtils.parseMLine = function(mediaSection) {
+  var lines = SDPUtils.splitLines(mediaSection);
+  var parts = lines[0].substr(2).split(' ');
+  return {
+    kind: parts[0],
+    port: parseInt(parts[1], 10),
+    protocol: parts[2],
+    fmt: parts.slice(3).join(' ')
+  };
+};
+
+SDPUtils.parseOLine = function(mediaSection) {
+  var line = SDPUtils.matchPrefix(mediaSection, 'o=')[0];
+  var parts = line.substr(2).split(' ');
+  return {
+    username: parts[0],
+    sessionId: parts[1],
+    sessionVersion: parseInt(parts[2], 10),
+    netType: parts[3],
+    addressType: parts[4],
+    address: parts[5],
+  };
+}
+
+// Expose public methods.
+if (true) {
+  module.exports = SDPUtils;
+}
+
+
+/***/ }),
+
+/***/ "./src/index.js":
+/*!**********************!*\
+  !*** ./src/index.js ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+var mj = __webpack_require__(/*! minijanus */ "./node_modules/minijanus/minijanus.js");
+var sdpUtils = __webpack_require__(/*! sdp */ "./node_modules/sdp/sdp.js");
+var debug = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js")("naf-janus-adapter:debug");
+var warn = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js")("naf-janus-adapter:warn");
+var error = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js")("naf-janus-adapter:error");
+var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+
+const SUBSCRIBE_TIMEOUT_MS = 15000;
+
+const AVAILABLE_OCCUPANTS_THRESHOLD = 5;
+const MAX_SUBSCRIBE_DELAY = 5000;
+
+function randomDelay(min, max) {
+  return new Promise(resolve => {
+    const delay = Math.random() * (max - min) + min;
+    setTimeout(resolve, delay);
+  });
+}
+
+function debounce(fn) {
+  var curr = Promise.resolve();
+  return function () {
+    var args = Array.prototype.slice.call(arguments);
+    curr = curr.then(_ => fn.apply(this, args));
+  };
+}
+
+function randomUint() {
+  return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+}
+
+function untilDataChannelOpen(dataChannel) {
+  return new Promise((resolve, reject) => {
+    if (dataChannel.readyState === "open") {
+      resolve();
+    } else {
+      let resolver, rejector;
+
+      const clear = () => {
+        dataChannel.removeEventListener("open", resolver);
+        dataChannel.removeEventListener("error", rejector);
+      };
+
+      resolver = () => {
+        clear();
+        resolve();
+      };
+      rejector = () => {
+        clear();
+        reject();
+      };
+
+      dataChannel.addEventListener("open", resolver);
+      dataChannel.addEventListener("error", rejector);
+    }
+  });
+}
+
+const isH264VideoSupported = (() => {
+  const video = document.createElement("video");
+  return video.canPlayType('video/mp4; codecs="avc1.42E01E, mp4a.40.2"') !== "";
+})();
+
+const OPUS_PARAMETERS = {
+  // indicates that we want to enable DTX to elide silence packets
+  usedtx: 1,
+  // indicates that we prefer to receive mono audio (important for voip profile)
+  stereo: 0,
+  // indicates that we prefer to send mono audio (important for voip profile)
+  "sprop-stereo": 0
+};
+
+const DEFAULT_PEER_CONNECTION_CONFIG = {
+  iceServers: [{ urls: "stun:stun1.l.google.com:19302" }, { urls: "stun:stun2.l.google.com:19302" }]
+};
+
+const WS_NORMAL_CLOSURE = 1000;
+
+class JanusAdapter {
+  constructor() {
+    this.room = null;
+    // We expect the consumer to set a client id before connecting.
+    this.clientId = null;
+    this.joinToken = null;
+
+    this.serverUrl = null;
+    this.webRtcOptions = {};
+    this.peerConnectionConfig = null;
+    this.ws = null;
+    this.session = null;
+    this.reliableTransport = "datachannel";
+    this.unreliableTransport = "datachannel";
+
+    // In the event the server restarts and all clients lose connection, reconnect with
+    // some random jitter added to prevent simultaneous reconnection requests.
+    this.initialReconnectionDelay = 1000 * Math.random();
+    this.reconnectionDelay = this.initialReconnectionDelay;
+    this.reconnectionTimeout = null;
+    this.maxReconnectionAttempts = 10;
+    this.reconnectionAttempts = 0;
+
+    this.publisher = null;
+    this.occupantIds = [];
+    this.occupants = {};
+    this.mediaStreams = {};
+    this.localMediaStream = null;
+    this.pendingMediaRequests = new Map();
+
+    this.pendingOccupants = new Set();
+    this.availableOccupants = [];
+    this.requestedOccupants = null;
+
+    this.blockedClients = new Map();
+    this.frozenUpdates = new Map();
+
+    this.timeOffsets = [];
+    this.serverTimeRequests = 0;
+    this.avgTimeOffset = 0;
+
+    this.onWebsocketOpen = this.onWebsocketOpen.bind(this);
+    this.onWebsocketClose = this.onWebsocketClose.bind(this);
+    this.onWebsocketMessage = this.onWebsocketMessage.bind(this);
+    this.onDataChannelMessage = this.onDataChannelMessage.bind(this);
+    this.onData = this.onData.bind(this);
+  }
+
+  setServerUrl(url) {
+    this.serverUrl = url;
+  }
+
+  setApp(app) {}
+
+  setRoom(roomName) {
+    this.room = roomName;
+  }
+
+  setJoinToken(joinToken) {
+    this.joinToken = joinToken;
+  }
+
+  setClientId(clientId) {
+    this.clientId = clientId;
+  }
+
+  setWebRtcOptions(options) {
+    this.webRtcOptions = options;
+  }
+
+  setPeerConnectionConfig(peerConnectionConfig) {
+    this.peerConnectionConfig = peerConnectionConfig;
+  }
+
+  setServerConnectListeners(successListener, failureListener) {
+    this.connectSuccess = successListener;
+    this.connectFailure = failureListener;
+  }
+
+  setRoomOccupantListener(occupantListener) {
+    this.onOccupantsChanged = occupantListener;
+  }
+
+  setDataChannelListeners(openListener, closedListener, messageListener) {
+    this.onOccupantConnected = openListener;
+    this.onOccupantDisconnected = closedListener;
+    this.onOccupantMessage = messageListener;
+  }
+
+  setReconnectionListeners(reconnectingListener, reconnectedListener, reconnectionErrorListener) {
+    // onReconnecting is called with the number of milliseconds until the next reconnection attempt
+    this.onReconnecting = reconnectingListener;
+    // onReconnected is called when the connection has been reestablished
+    this.onReconnected = reconnectedListener;
+    // onReconnectionError is called with an error when maxReconnectionAttempts has been reached
+    this.onReconnectionError = reconnectionErrorListener;
+  }
+
+  connect() {
+    debug(`connecting to ${this.serverUrl}`);
+
+    const websocketConnection = new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.serverUrl, "janus-protocol");
+
+      this.session = new mj.JanusSession(this.ws.send.bind(this.ws), { timeoutMs: 30000 });
+
+      let onOpen;
+
+      const onError = () => {
+        reject(error);
+      };
+
+      this.ws.addEventListener("close", this.onWebsocketClose);
+      this.ws.addEventListener("message", this.onWebsocketMessage);
+
+      onOpen = () => {
+        this.ws.removeEventListener("open", onOpen);
+        this.ws.removeEventListener("error", onError);
+        this.onWebsocketOpen().then(resolve).catch(reject);
+      };
+
+      this.ws.addEventListener("open", onOpen);
+    });
+
+    return Promise.all([websocketConnection, this.updateTimeOffset()]);
+  }
+
+  disconnect() {
+    debug(`disconnecting`);
+
+    clearTimeout(this.reconnectionTimeout);
+
+    this.removeAllOccupants();
+
+    if (this.publisher) {
+      // Close the publisher peer connection. Which also detaches the plugin handle.
+      this.publisher.conn.close();
+      this.publisher = null;
+    }
+
+    if (this.session) {
+      this.session.dispose();
+      this.session = null;
+    }
+
+    if (this.ws) {
+      this.ws.removeEventListener("open", this.onWebsocketOpen);
+      this.ws.removeEventListener("close", this.onWebsocketClose);
+      this.ws.removeEventListener("message", this.onWebsocketMessage);
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  isDisconnected() {
+    return this.ws === null;
+  }
+
+  onWebsocketOpen() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // Create the Janus Session
+      yield _this.session.create();
+
+      // Attach the SFU Plugin and create a RTCPeerConnection for the publisher.
+      // The publisher sends audio and opens two bidirectional data channels.
+      // One reliable datachannel and one unreliable.
+      _this.publisher = yield _this.createPublisher();
+
+      // Call the naf connectSuccess callback before we start receiving WebRTC messages.
+      _this.connectSuccess(_this.clientId);
+
+      for (let i = 0; i < _this.publisher.initialOccupants.length; i++) {
+        const occupantId = _this.publisher.initialOccupants[i];
+        if (occupantId === _this.clientId) continue; // Happens during non-graceful reconnects due to zombie sessions
+        _this.addAvailableOccupant(occupantId);
+      }
+
+      _this.syncOccupants(_this.availableOccupants);
+    })();
+  }
+
+  onWebsocketClose(event) {
+    // The connection was closed successfully. Don't try to reconnect.
+    if (event.code === WS_NORMAL_CLOSURE) {
+      return;
+    }
+
+    if (this.onReconnecting) {
+      this.onReconnecting(this.reconnectionDelay);
+    }
+
+    this.reconnectionTimeout = setTimeout(() => this.reconnect(), this.reconnectionDelay);
+  }
+
+  reconnect() {
+    // Dispose of all networked entities and other resources tied to the session.
+    this.disconnect();
+
+    this.connect().then(() => {
+      this.reconnectionDelay = this.initialReconnectionDelay;
+      this.reconnectionAttempts = 0;
+
+      if (this.onReconnected) {
+        this.onReconnected();
+      }
+    }).catch(error => {
+      this.reconnectionDelay += 1000;
+      this.reconnectionAttempts++;
+
+      if (this.reconnectionAttempts > this.maxReconnectionAttempts && this.onReconnectionError) {
+        return this.onReconnectionError(new Error("Connection could not be reestablished, exceeded maximum number of reconnection attempts."));
+      }
+
+      console.warn("Error during reconnect, retrying.");
+      console.warn(error);
+
+      if (this.onReconnecting) {
+        this.onReconnecting(this.reconnectionDelay);
+      }
+
+      this.reconnectionTimeout = setTimeout(() => this.reconnect(), this.reconnectionDelay);
+    });
+  }
+
+  performDelayedReconnect() {
+    if (this.delayedReconnectTimeout) {
+      clearTimeout(this.delayedReconnectTimeout);
+    }
+
+    this.delayedReconnectTimeout = setTimeout(() => {
+      this.delayedReconnectTimeout = null;
+      this.reconnect();
+    }, 10000);
+  }
+
+  onWebsocketMessage(event) {
+    this.session.receive(JSON.parse(event.data));
+  }
+
+  addAvailableOccupant(occupantId) {
+    if (this.availableOccupants.indexOf(occupantId) === -1) {
+      this.availableOccupants.push(occupantId);
+    }
+  }
+
+  removeAvailableOccupant(occupantId) {
+    const idx = this.availableOccupants.indexOf(occupantId);
+    if (idx !== -1) {
+      this.availableOccupants.splice(idx, 1);
+    }
+  }
+
+  syncOccupants(requestedOccupants) {
+    if (requestedOccupants) {
+      this.requestedOccupants = requestedOccupants;
+    }
+
+    if (!this.requestedOccupants) {
+      return;
+    }
+
+    // Add any requested, available, and non-pending occupants.
+    for (let i = 0; i < this.requestedOccupants.length; i++) {
+      const occupantId = this.requestedOccupants[i];
+      if (!this.occupants[occupantId] && this.availableOccupants.indexOf(occupantId) !== -1 && !this.pendingOccupants.has(occupantId)) {
+        this.addOccupant(occupantId);
+      }
+    }
+
+    // Remove any unrequested and currently added occupants.
+    for (let j = 0; j < this.availableOccupants.length; j++) {
+      const occupantId = this.availableOccupants[j];
+      if (this.occupants[occupantId] && this.requestedOccupants.indexOf(occupantId) === -1) {
+        this.removeOccupant(occupantId);
+      }
+    }
+
+    // Call the Networked AFrame callbacks for the updated occupants list.
+    this.onOccupantsChanged(this.occupants);
+  }
+
+  addOccupant(occupantId) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      _this2.pendingOccupants.add(occupantId);
+
+      const availableOccupantsCount = _this2.availableOccupants.length;
+      if (availableOccupantsCount > AVAILABLE_OCCUPANTS_THRESHOLD) {
+        yield randomDelay(0, MAX_SUBSCRIBE_DELAY);
+      }
+
+      const subscriber = yield _this2.createSubscriber(occupantId);
+      if (subscriber) {
+        if (!_this2.pendingOccupants.has(occupantId)) {
+          subscriber.conn.close();
+        } else {
+          _this2.pendingOccupants.delete(occupantId);
+          _this2.occupantIds.push(occupantId);
+          _this2.occupants[occupantId] = subscriber;
+console.log('ADD THE OCCUPANT', _this2.occupants);
+
+          _this2.setMediaStream(occupantId, subscriber.mediaStream);
+
+          // Call the Networked AFrame callbacks for the new occupant.
+          _this2.onOccupantConnected(occupantId);
+        }
+      }
+    })();
+  }
+
+  removeAllOccupants() {
+    this.pendingOccupants.clear();
+    for (let i = this.occupantIds.length - 1; i >= 0; i--) {
+      this.removeOccupant(this.occupantIds[i]);
+    }
+  }
+
+  removeOccupant(occupantId) {
+    this.pendingOccupants.delete(occupantId);
+
+    if (this.occupants[occupantId]) {
+      // Close the subscriber peer connection. Which also detaches the plugin handle.
+      this.occupants[occupantId].conn.close();
+      delete this.occupants[occupantId];
+
+      this.occupantIds.splice(this.occupantIds.indexOf(occupantId), 1);
+    }
+
+    if (this.mediaStreams[occupantId]) {
+      delete this.mediaStreams[occupantId];
+    }
+
+    if (this.pendingMediaRequests.has(occupantId)) {
+      const msg = "The user disconnected before the media stream was resolved.";
+      this.pendingMediaRequests.get(occupantId).audio.reject(msg);
+      this.pendingMediaRequests.get(occupantId).video.reject(msg);
+      this.pendingMediaRequests.delete(occupantId);
+    }
+
+    // Call the Networked AFrame callbacks for the removed occupant.
+    this.onOccupantDisconnected(occupantId);
+  }
+
+  associate(conn, handle) {
+    conn.addEventListener("icecandidate", ev => {
+      handle.sendTrickle(ev.candidate || null).catch(e => error("Error trickling ICE: %o", e));
+    });
+    conn.addEventListener("iceconnectionstatechange", ev => {
+      if (conn.iceConnectionState === "failed") {
+        console.warn("ICE failure detected. Reconnecting in 10s.");
+        this.performDelayedReconnect();
+      }
+    });
+
+    // we have to debounce these because janus gets angry if you send it a new SDP before
+    // it's finished processing an existing SDP. in actuality, it seems like this is maybe
+    // too liberal and we need to wait some amount of time after an offer before sending another,
+    // but we don't currently know any good way of detecting exactly how long :(
+    conn.addEventListener("negotiationneeded", debounce(ev => {
+      debug("Sending new offer for handle: %o", handle);
+      var offer = conn.createOffer().then(this.configurePublisherSdp).then(this.fixSafariIceUFrag);
+      var local = offer.then(o => conn.setLocalDescription(o));
+      var remote = offer;
+
+      remote = remote.then(this.fixSafariIceUFrag).then(j => handle.sendJsep(j)).then(r => conn.setRemoteDescription(r.jsep));
+      return Promise.all([local, remote]).catch(e => error("Error negotiating offer: %o", e));
+    }));
+    handle.on("event", debounce(ev => {
+      var jsep = ev.jsep;
+      if (jsep && jsep.type == "offer") {
+        debug("Accepting new offer for handle: %o", handle);
+        var answer = conn.setRemoteDescription(this.configureSubscriberSdp(jsep)).then(_ => conn.createAnswer()).then(this.fixSafariIceUFrag);
+        var local = answer.then(a => conn.setLocalDescription(a));
+        var remote = answer.then(j => handle.sendJsep(j));
+        return Promise.all([local, remote]).catch(e => error("Error negotiating answer: %o", e));
+      } else {
+        // some other kind of event, nothing to do
+        return null;
+      }
+    }));
+  }
+
+  createPublisher() {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      var handle = new mj.JanusPluginHandle(_this3.session);
+      var conn = new RTCPeerConnection(_this3.peerConnectionConfig || DEFAULT_PEER_CONNECTION_CONFIG);
+
+      debug("pub waiting for sfu");
+      yield handle.attach("janus.plugin.sfu");
+
+      _this3.associate(conn, handle);
+
+      debug("pub waiting for data channels & webrtcup");
+      var webrtcup = new Promise(function (resolve) {
+        return handle.on("webrtcup", resolve);
+      });
+
+      // Unreliable datachannel: sending and receiving component updates.
+      // Reliable datachannel: sending and recieving entity instantiations.
+      var reliableChannel = conn.createDataChannel("reliable", { ordered: true });
+      var unreliableChannel = conn.createDataChannel("unreliable", {
+        ordered: false,
+        maxRetransmits: 0
+      });
+
+      reliableChannel.addEventListener("message", function (e) {
+        return _this3.onDataChannelMessage(e, "janus-reliable");
+      });
+      unreliableChannel.addEventListener("message", function (e) {
+        return _this3.onDataChannelMessage(e, "janus-unreliable");
+      });
+
+      yield webrtcup;
+      yield untilDataChannelOpen(reliableChannel);
+      yield untilDataChannelOpen(unreliableChannel);
+
+      // doing this here is sort of a hack around chrome renegotiation weirdness --
+      // if we do it prior to webrtcup, chrome on gear VR will sometimes put a
+      // renegotiation offer in flight while the first offer was still being
+      // processed by janus. we should find some more principled way to figure out
+      // when janus is done in the future.
+      if (_this3.localMediaStream) {
+        _this3.localMediaStream.getTracks().forEach(function (track) {
+          conn.addTrack(track, _this3.localMediaStream);
+        });
+      }
+
+      // Handle all of the join and leave events.
+      handle.on("event", function (ev) {
+        var data = ev.plugindata.data;
+        if (data.event == "join" && data.room_id == _this3.room) {
+          _this3.addAvailableOccupant(data.user_id);
+          _this3.syncOccupants(_this3.availableOccupants);
+        } else if (data.event == "leave" && data.room_id == _this3.room) {
+          _this3.removeAvailableOccupant(data.user_id);
+          _this3.removeOccupant(data.user_id);
+        } else if (data.event == "blocked") {
+          document.body.dispatchEvent(new CustomEvent("blocked", { detail: { clientId: data.by } }));
+        } else if (data.event == "unblocked") {
+          document.body.dispatchEvent(new CustomEvent("unblocked", { detail: { clientId: data.by } }));
+        } else if (data.event === "data") {
+          _this3.onData(JSON.parse(data.body), "janus-event");
+        }
+      });
+
+      debug("pub waiting for join");
+
+      // Send join message to janus. Listen for join/leave messages. Automatically subscribe to all users' WebRTC data.
+      var message = yield _this3.sendJoin(handle, {
+        notifications: true,
+        data: true
+      });
+
+      if (!message.plugindata.data.success) {
+        const err = message.plugindata.data.error;
+        console.error(err);
+        throw err;
+      }
+
+      var initialOccupants = message.plugindata.data.response.users[_this3.room] || [];
+
+      if (initialOccupants.includes(_this3.clientId)) {
+        console.warn("Janus still has previous session for this client. Reconnecting in 10s.");
+        _this3.performDelayedReconnect();
+      }
+
+      debug("publisher ready");
+      return {
+        handle,
+        initialOccupants,
+        reliableChannel,
+        unreliableChannel,
+        conn
+      };
+    })();
+  }
+
+  configurePublisherSdp(jsep) {
+    jsep.sdp = jsep.sdp.replace(/a=fmtp:(109|111).*\r\n/g, (line, pt) => {
+      const parameters = Object.assign(sdpUtils.parseFmtp(line), OPUS_PARAMETERS);
+      return sdpUtils.writeFmtp({ payloadType: pt, parameters: parameters });
+    });
+    return jsep;
+  }
+
+  configureSubscriberSdp(jsep) {
+    // todo: consider cleaning up these hacks to use sdputils
+    if (!isH264VideoSupported) {
+      if (navigator.userAgent.indexOf("HeadlessChrome") !== -1) {
+        // HeadlessChrome (e.g. puppeteer) doesn't support webrtc video streams, so we remove those lines from the SDP.
+        jsep.sdp = jsep.sdp.replace(/m=video[^]*m=/, "m=");
+      }
+    }
+
+    // TODO: Hack to get video working on Chrome for Android. https://groups.google.com/forum/#!topic/mozilla.dev.media/Ye29vuMTpo8
+    if (navigator.userAgent.indexOf("Android") === -1) {
+      jsep.sdp = jsep.sdp.replace("a=rtcp-fb:107 goog-remb\r\n", "a=rtcp-fb:107 goog-remb\r\na=rtcp-fb:107 transport-cc\r\na=fmtp:107 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f\r\n");
+    } else {
+      jsep.sdp = jsep.sdp.replace("a=rtcp-fb:107 goog-remb\r\n", "a=rtcp-fb:107 goog-remb\r\na=rtcp-fb:107 transport-cc\r\na=fmtp:107 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f\r\n");
+    }
+    return jsep;
+  }
+
+  fixSafariIceUFrag(jsep) {
+    return _asyncToGenerator(function* () {
+      // Safari produces a \n instead of an \r\n for the ice-ufrag. See https://github.com/meetecho/janus-gateway/issues/1818
+      jsep.sdp = jsep.sdp.replace(/[^\r]\na=ice-ufrag/g, "\r\na=ice-ufrag");
+      return jsep;
+    })();
+  }
+
+  createSubscriber(occupantId) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this4.availableOccupants.indexOf(occupantId) === -1) {
+        console.warn(occupantId + ": cancelled occupant connection, occupant left before subscription negotation.");
+        return null;
+      }
+
+      var handle = new mj.JanusPluginHandle(_this4.session);
+      var conn = new RTCPeerConnection(_this4.peerConnectionConfig || DEFAULT_PEER_CONNECTION_CONFIG);
+
+      debug(occupantId + ": sub waiting for sfu");
+      yield handle.attach("janus.plugin.sfu");
+
+      _this4.associate(conn, handle);
+
+      debug(occupantId + ": sub waiting for join");
+
+      if (_this4.availableOccupants.indexOf(occupantId) === -1) {
+        conn.close();
+        console.warn(occupantId + ": cancelled occupant connection, occupant left after attach");
+        return null;
+      }
+
+      let webrtcFailed = false;
+
+      const webrtcup = new Promise(function (resolve) {
+        const leftInterval = setInterval(function () {
+          if (_this4.availableOccupants.indexOf(occupantId) === -1) {
+            clearInterval(leftInterval);
+            resolve();
+          }
+        }, 1000);
+
+        const timeout = setTimeout(function () {
+          clearInterval(leftInterval);
+          webrtcFailed = true;
+          resolve();
+        }, SUBSCRIBE_TIMEOUT_MS);
+
+        handle.on("webrtcup", function () {
+          clearTimeout(timeout);
+          clearInterval(leftInterval);
+          resolve();
+        });
+      });
+
+      // Send join message to janus. Don't listen for join/leave messages. Subscribe to the occupant's media.
+      // Janus should send us an offer for this occupant's media in response to this.
+      const resp = yield _this4.sendJoin(handle, { media: occupantId });
+
+      if (_this4.availableOccupants.indexOf(occupantId) === -1) {
+        conn.close();
+        console.warn(occupantId + ": cancelled occupant connection, occupant left after join");
+        return null;
+      }
+
+      debug(occupantId + ": sub waiting for webrtcup");
+      yield webrtcup;
+
+      if (_this4.availableOccupants.indexOf(occupantId) === -1) {
+        conn.close();
+        console.warn(occupantId + ": cancel occupant connection, occupant left during or after webrtcup");
+        return null;
+      }
+
+      if (webrtcFailed) {
+        conn.close();
+        console.warn(occupantId + ": webrtc up timed out");
+        return null;
+      }
+
+      if (isSafari && !_this4._iOSHackDelayedInitialPeer) {
+        // HACK: the first peer on Safari during page load can fail to work if we don't
+        // wait some time before continuing here. See: https://github.com/mozilla/hubs/pull/1692
+        yield new Promise(function (resolve) {
+          return setTimeout(resolve, 3000);
+        });
+        _this4._iOSHackDelayedInitialPeer = true;
+      }
+
+      var mediaStream = new MediaStream();
+      var receivers = conn.getReceivers();
+      receivers.forEach(function (receiver) {
+        if (receiver.track) {
+          mediaStream.addTrack(receiver.track);
+        }
+      });
+      if (mediaStream.getTracks().length === 0) {
+        mediaStream = null;
+      }
+
+      debug(occupantId + ": subscriber ready");
+      return {
+        handle,
+        mediaStream,
+        conn
+      };
+    })();
+  }
+
+  sendJoin(handle, subscribe) {
+    return handle.sendMessage({
+      kind: "join",
+      room_id: this.room,
+      user_id: this.clientId,
+      subscribe,
+      token: this.joinToken
+    });
+  }
+
+  toggleFreeze() {
+    if (this.frozen) {
+      this.unfreeze();
+    } else {
+      this.freeze();
+    }
+  }
+
+  freeze() {
+    this.frozen = true;
+  }
+
+  unfreeze() {
+    this.frozen = false;
+    this.flushPendingUpdates();
+  }
+
+  dataForUpdateMultiMessage(networkId, message) {
+    // "d" is an array of entity datas, where each item in the array represents a unique entity and contains
+    // metadata for the entity, and an array of components that have been updated on the entity.
+    // This method finds the data corresponding to the given networkId.
+    for (let i = 0, l = message.data.d.length; i < l; i++) {
+      const data = message.data.d[i];
+
+      if (data.networkId === networkId) {
+        return data;
+      }
+    }
+
+    return null;
+  }
+
+  getPendingData(networkId, message) {
+    if (!message) return null;
+
+    let data = message.dataType === "um" ? this.dataForUpdateMultiMessage(networkId, message) : message.data;
+
+    // Ignore messages relating to users who have disconnected since freezing, their entities
+    // will have aleady been removed by NAF.
+    // Note that delete messages have no "owner" so we have to check for that as well.
+    if (data.owner && !this.occupants[data.owner]) return null;
+
+    // Ignore messages from users that we may have blocked while frozen.
+    if (data.owner && this.blockedClients.has(data.owner)) return null;
+
+    return data;
+  }
+
+  // Used externally
+  getPendingDataForNetworkId(networkId) {
+    return this.getPendingData(networkId, this.frozenUpdates.get(networkId));
+  }
+
+  flushPendingUpdates() {
+    for (const [networkId, message] of this.frozenUpdates) {
+      let data = this.getPendingData(networkId, message);
+      if (!data) continue;
+
+      // Override the data type on "um" messages types, since we extract entity updates from "um" messages into
+      // individual frozenUpdates in storeSingleMessage.
+      const dataType = message.dataType === "um" ? "u" : message.dataType;
+
+      this.onOccupantMessage(null, dataType, data, message.source);
+    }
+    this.frozenUpdates.clear();
+  }
+
+  storeMessage(message) {
+    if (message.dataType === "um") {
+      // UpdateMulti
+      for (let i = 0, l = message.data.d.length; i < l; i++) {
+        this.storeSingleMessage(message, i);
+      }
+    } else {
+      this.storeSingleMessage(message);
+    }
+  }
+
+  storeSingleMessage(message, index) {
+    const data = index !== undefined ? message.data.d[index] : message.data;
+    const dataType = message.dataType;
+    const source = message.source;
+
+    const networkId = data.networkId;
+
+    if (!this.frozenUpdates.has(networkId)) {
+      this.frozenUpdates.set(networkId, message);
+    } else {
+      const storedMessage = this.frozenUpdates.get(networkId);
+      const storedData = storedMessage.dataType === "um" ? this.dataForUpdateMultiMessage(networkId, storedMessage) : storedMessage.data;
+
+      // Avoid updating components if the entity data received did not come from the current owner.
+      const isOutdatedMessage = data.lastOwnerTime < storedData.lastOwnerTime;
+      const isContemporaneousMessage = data.lastOwnerTime === storedData.lastOwnerTime;
+      if (isOutdatedMessage || isContemporaneousMessage && storedData.owner > data.owner) {
+        return;
+      }
+
+      if (dataType === "r") {
+        const createdWhileFrozen = storedData && storedData.isFirstSync;
+        if (createdWhileFrozen) {
+          // If the entity was created and deleted while frozen, don't bother conveying anything to the consumer.
+          this.frozenUpdates.delete(networkId);
+        } else {
+          // Delete messages override any other messages for this entity
+          this.frozenUpdates.set(networkId, message);
+        }
+      } else {
+        // merge in component updates
+        if (storedData.components && data.components) {
+          Object.assign(storedData.components, data.components);
+        }
+      }
+    }
+  }
+
+  onDataChannelMessage(e, source) {
+    this.onData(JSON.parse(e.data), source);
+  }
+
+  onData(message, source) {
+    if (debug.enabled) {
+      debug(`DC in: ${message}`);
+    }
+
+    if (!message.dataType) return;
+
+    message.source = source;
+
+    if (this.frozen) {
+      this.storeMessage(message);
+    } else {
+      this.onOccupantMessage(null, message.dataType, message.data, message.source);
+    }
+  }
+
+  shouldStartConnectionTo(client) {
+    return true;
+  }
+
+  startStreamConnection(client) {}
+
+  closeStreamConnection(client) {}
+
+  getConnectStatus(clientId) {
+    return this.occupants[clientId] ? NAF.adapters.IS_CONNECTED : NAF.adapters.NOT_CONNECTED;
+  }
+
+  updateTimeOffset() {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this5.isDisconnected()) return;
+
+      const clientSentTime = Date.now();
+
+      const res = yield fetch(document.location.href, {
+        method: "HEAD",
+        cache: "no-cache"
+      });
+
+      const precision = 1000;
+      const serverReceivedTime = new Date(res.headers.get("Date")).getTime() + precision / 2;
+      const clientReceivedTime = Date.now();
+      const serverTime = serverReceivedTime + (clientReceivedTime - clientSentTime) / 2;
+      const timeOffset = serverTime - clientReceivedTime;
+
+      _this5.serverTimeRequests++;
+
+      if (_this5.serverTimeRequests <= 10) {
+        _this5.timeOffsets.push(timeOffset);
+      } else {
+        _this5.timeOffsets[_this5.serverTimeRequests % 10] = timeOffset;
+      }
+
+      _this5.avgTimeOffset = _this5.timeOffsets.reduce(function (acc, offset) {
+        return acc += offset;
+      }, 0) / _this5.timeOffsets.length;
+
+      if (_this5.serverTimeRequests > 10) {
+        debug(`new server time offset: ${_this5.avgTimeOffset}ms`);
+        setTimeout(function () {
+          return _this5.updateTimeOffset();
+        }, 5 * 60 * 1000); // Sync clock every 5 minutes.
+      } else {
+        _this5.updateTimeOffset();
+      }
+    })();
+  }
+
+  getServerTime() {
+    return Date.now() + this.avgTimeOffset;
+  }
+
+  getMediaStream(clientId, type = "audio") {
+    if (this.mediaStreams[clientId]) {
+      debug(`Already had ${type} for ${clientId}`);
+      return Promise.resolve(this.mediaStreams[clientId][type]);
+    } else {
+      debug(`Waiting on ${type} for ${clientId}`);
+      if (!this.pendingMediaRequests.has(clientId)) {
+        this.pendingMediaRequests.set(clientId, {});
+
+        const audioPromise = new Promise((resolve, reject) => {
+          this.pendingMediaRequests.get(clientId).audio = { resolve, reject };
+        });
+        const videoPromise = new Promise((resolve, reject) => {
+          this.pendingMediaRequests.get(clientId).video = { resolve, reject };
+        });
+
+        this.pendingMediaRequests.get(clientId).audio.promise = audioPromise;
+        this.pendingMediaRequests.get(clientId).video.promise = videoPromise;
+
+        audioPromise.catch(e => console.warn(`${clientId} getMediaStream Audio Error`, e));
+        videoPromise.catch(e => console.warn(`${clientId} getMediaStream Video Error`, e));
+      }
+      return this.pendingMediaRequests.get(clientId)[type].promise;
+    }
+  }
+
+  setMediaStream(clientId, stream) {
+    // Safari doesn't like it when you use single a mixed media stream where one of the tracks is inactive, so we
+    // split the tracks into two streams.
+    const audioStream = new MediaStream();
+    try {
+      stream.getAudioTracks().forEach(track => audioStream.addTrack(track));
+    } catch (e) {
+      console.warn(`${clientId} setMediaStream Audio Error`, e);
+    }
+    const videoStream = new MediaStream();
+    try {
+      stream.getVideoTracks().forEach(track => videoStream.addTrack(track));
+    } catch (e) {
+      console.warn(`${clientId} setMediaStream Video Error`, e);
+    }
+
+    this.mediaStreams[clientId] = { audio: audioStream, video: videoStream };
+
+    // Resolve the promise for the user's media stream if it exists.
+    if (this.pendingMediaRequests.has(clientId)) {
+      this.pendingMediaRequests.get(clientId).audio.resolve(audioStream);
+      this.pendingMediaRequests.get(clientId).video.resolve(videoStream);
+    }
+  }
+
+  setLocalMediaStream(stream) {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      // our job here is to make sure the connection winds up with RTP senders sending the stuff in this stream,
+      // and not the stuff that isn't in this stream. strategy is to replace existing tracks if we can, add tracks
+      // that we can't replace, and disable tracks that don't exist anymore.
+
+      // note that we don't ever remove a track from the stream -- since Janus doesn't support Unified Plan, we absolutely
+      // can't wind up with a SDP that has >1 audio or >1 video tracks, even if one of them is inactive (what you get if
+      // you remove a track from an existing stream.)
+      if (_this6.publisher && _this6.publisher.conn) {
+        const existingSenders = _this6.publisher.conn.getSenders();
+        const newSenders = [];
+        const tracks = stream.getTracks();
+
+        for (let i = 0; i < tracks.length; i++) {
+          const t = tracks[i];
+          const sender = existingSenders.find(function (s) {
+            return s.track != null && s.track.kind == t.kind;
+          });
+
+          if (sender != null) {
+            if (sender.replaceTrack) {
+              yield sender.replaceTrack(t);
+
+              // Workaround https://bugzilla.mozilla.org/show_bug.cgi?id=1576771
+              if (t.kind === "video" && t.enabled && navigator.userAgent.toLowerCase().indexOf('firefox') > -1) {
+                t.enabled = false;
+                setTimeout(function () {
+                  return t.enabled = true;
+                }, 1000);
+              }
+            } else {
+              // Fallback for browsers that don't support replaceTrack. At this time of this writing
+              // most browsers support it, and testing this code path seems to not work properly
+              // in Chrome anymore.
+              stream.removeTrack(sender.track);
+              stream.addTrack(t);
+            }
+            newSenders.push(sender);
+          } else {
+            newSenders.push(_this6.publisher.conn.addTrack(t, stream));
+          }
+        }
+        existingSenders.forEach(function (s) {
+          if (!newSenders.includes(s)) {
+            s.track.enabled = false;
+          }
+        });
+      }
+      _this6.localMediaStream = stream;
+      _this6.setMediaStream(_this6.clientId, stream);
+    })();
+  }
+
+  enableMicrophone(enabled) {
+    if (this.publisher && this.publisher.conn) {
+      this.publisher.conn.getSenders().forEach(s => {
+        if (s.track.kind == "audio") {
+          s.track.enabled = enabled;
+        }
+      });
+    }
+  }
+
+  sendData(clientId, dataType, data) {
+    if (!this.publisher) {
+      console.warn("sendData called without a publisher");
+    } else {
+      switch (this.unreliableTransport) {
+        case "websocket":
+          this.publisher.handle.sendMessage({ kind: "data", body: JSON.stringify({ dataType, data }), whom: clientId });
+          break;
+        case "datachannel":
+          this.publisher.unreliableChannel.send(JSON.stringify({ clientId, dataType, data }));
+          break;
+        default:
+          this.unreliableTransport(clientId, dataType, data);
+          break;
+      }
+    }
+  }
+
+  sendDataGuaranteed(clientId, dataType, data) {
+    if (!this.publisher) {
+      console.warn("sendDataGuaranteed called without a publisher");
+    } else {
+      switch (this.reliableTransport) {
+        case "websocket":
+          this.publisher.handle.sendMessage({ kind: "data", body: JSON.stringify({ dataType, data }), whom: clientId });
+          break;
+        case "datachannel":
+          this.publisher.reliableChannel.send(JSON.stringify({ clientId, dataType, data }));
+          break;
+        default:
+          this.reliableTransport(clientId, dataType, data);
+          break;
+      }
+    }
+  }
+
+  broadcastData(dataType, data) {
+    if (!this.publisher) {
+      console.warn("broadcastData called without a publisher");
+    } else {
+      switch (this.unreliableTransport) {
+        case "websocket":
+          this.publisher.handle.sendMessage({ kind: "data", body: JSON.stringify({ dataType, data }) });
+          break;
+        case "datachannel":
+          this.publisher.unreliableChannel.send(JSON.stringify({ dataType, data }));
+          break;
+        default:
+          this.unreliableTransport(undefined, dataType, data);
+          break;
+      }
+    }
+  }
+
+  broadcastDataGuaranteed(dataType, data) {
+    if (!this.publisher) {
+      console.warn("broadcastDataGuaranteed called without a publisher");
+    } else {
+      switch (this.reliableTransport) {
+        case "websocket":
+          this.publisher.handle.sendMessage({ kind: "data", body: JSON.stringify({ dataType, data }) });
+          break;
+        case "datachannel":
+          this.publisher.reliableChannel.send(JSON.stringify({ dataType, data }));
+          break;
+        default:
+          this.reliableTransport(undefined, dataType, data);
+          break;
+      }
+    }
+  }
+
+  kick(clientId, permsToken) {
+    return this.publisher.handle.sendMessage({ kind: "kick", room_id: this.room, user_id: clientId, token: permsToken }).then(() => {
+      document.body.dispatchEvent(new CustomEvent("kicked", { detail: { clientId: clientId } }));
+    });
+  }
+
+  block(clientId) {
+    return this.publisher.handle.sendMessage({ kind: "block", whom: clientId }).then(() => {
+      this.blockedClients.set(clientId, true);
+      document.body.dispatchEvent(new CustomEvent("blocked", { detail: { clientId: clientId } }));
+    });
+  }
+
+  unblock(clientId) {
+    return this.publisher.handle.sendMessage({ kind: "unblock", whom: clientId }).then(() => {
+      this.blockedClients.delete(clientId);
+      document.body.dispatchEvent(new CustomEvent("unblocked", { detail: { clientId: clientId } }));
+    });
+  }
+}
+
+NAF.adapters.register("janus", JanusAdapter);
+
+module.exports = JanusAdapter;
+
+/***/ })
+
+/******/ });
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/debug/src/browser.js","webpack:///./node_modules/debug/src/debug.js","webpack:///./node_modules/minijanus/minijanus.js","webpack:///./node_modules/ms/index.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/sdp/sdp.js","webpack:///./src/index.js"],"names":["mj","require","sdpUtils","debug","warn","error","isSafari","test","navigator","userAgent","SUBSCRIBE_TIMEOUT_MS","AVAILABLE_OCCUPANTS_THRESHOLD","MAX_SUBSCRIBE_DELAY","randomDelay","min","max","Promise","resolve","delay","Math","random","setTimeout","debounce","fn","curr","args","Array","prototype","slice","call","arguments","then","_","apply","randomUint","floor","Number","MAX_SAFE_INTEGER","untilDataChannelOpen","dataChannel","reject","readyState","resolver","rejector","clear","removeEventListener","addEventListener","isH264VideoSupported","video","document","createElement","canPlayType","OPUS_PARAMETERS","usedtx","stereo","DEFAULT_PEER_CONNECTION_CONFIG","iceServers","urls","WS_NORMAL_CLOSURE","JanusAdapter","constructor","room","clientId","joinToken","serverUrl","webRtcOptions","peerConnectionConfig","ws","session","reliableTransport","unreliableTransport","initialReconnectionDelay","reconnectionDelay","reconnectionTimeout","maxReconnectionAttempts","reconnectionAttempts","publisher","occupantIds","occupants","mediaStreams","localMediaStream","pendingMediaRequests","Map","pendingOccupants","Set","availableOccupants","requestedOccupants","blockedClients","frozenUpdates","timeOffsets","serverTimeRequests","avgTimeOffset","onWebsocketOpen","bind","onWebsocketClose","onWebsocketMessage","onDataChannelMessage","onData","setServerUrl","url","setApp","app","setRoom","roomName","setJoinToken","setClientId","setWebRtcOptions","options","setPeerConnectionConfig","setServerConnectListeners","successListener","failureListener","connectSuccess","connectFailure","setRoomOccupantListener","occupantListener","onOccupantsChanged","setDataChannelListeners","openListener","closedListener","messageListener","onOccupantConnected","onOccupantDisconnected","onOccupantMessage","setReconnectionListeners","reconnectingListener","reconnectedListener","reconnectionErrorListener","onReconnecting","onReconnected","onReconnectionError","connect","websocketConnection","WebSocket","JanusSession","send","timeoutMs","onOpen","onError","catch","all","updateTimeOffset","disconnect","clearTimeout","removeAllOccupants","conn","close","dispose","isDisconnected","create","createPublisher","i","initialOccupants","length","occupantId","addAvailableOccupant","syncOccupants","event","code","reconnect","Error","console","performDelayedReconnect","delayedReconnectTimeout","receive","JSON","parse","data","indexOf","push","removeAvailableOccupant","idx","splice","has","addOccupant","j","removeOccupant","add","availableOccupantsCount","subscriber","createSubscriber","delete","setMediaStream","mediaStream","msg","get","audio","associate","handle","ev","sendTrickle","candidate","e","iceConnectionState","offer","createOffer","configurePublisherSdp","fixSafariIceUFrag","local","o","setLocalDescription","remote","sendJsep","r","setRemoteDescription","jsep","on","type","answer","configureSubscriberSdp","createAnswer","a","JanusPluginHandle","RTCPeerConnection","attach","webrtcup","reliableChannel","createDataChannel","ordered","unreliableChannel","maxRetransmits","getTracks","forEach","addTrack","track","plugindata","room_id","user_id","body","dispatchEvent","CustomEvent","detail","by","message","sendJoin","notifications","success","err","response","users","includes","sdp","replace","line","pt","parameters","Object","assign","parseFmtp","writeFmtp","payloadType","webrtcFailed","leftInterval","setInterval","clearInterval","timeout","resp","media","_iOSHackDelayedInitialPeer","MediaStream","receivers","getReceivers","receiver","subscribe","sendMessage","kind","token","toggleFreeze","frozen","unfreeze","freeze","flushPendingUpdates","dataForUpdateMultiMessage","networkId","l","d","getPendingData","dataType","owner","getPendingDataForNetworkId","source","storeMessage","storeSingleMessage","index","undefined","set","storedMessage","storedData","isOutdatedMessage","lastOwnerTime","isContemporaneousMessage","createdWhileFrozen","isFirstSync","components","enabled","shouldStartConnectionTo","client","startStreamConnection","closeStreamConnection","getConnectStatus","NAF","adapters","IS_CONNECTED","NOT_CONNECTED","clientSentTime","Date","now","res","fetch","location","href","method","cache","precision","serverReceivedTime","headers","getTime","clientReceivedTime","serverTime","timeOffset","reduce","acc","offset","getServerTime","getMediaStream","audioPromise","videoPromise","promise","stream","audioStream","getAudioTracks","videoStream","getVideoTracks","setLocalMediaStream","existingSenders","getSenders","newSenders","tracks","t","sender","find","s","replaceTrack","toLowerCase","removeTrack","enableMicrophone","sendData","stringify","whom","sendDataGuaranteed","broadcastData","broadcastDataGuaranteed","kick","permsToken","block","unblock","register","module","exports"],"mappings":";QAAA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;QAEA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;;;QAGA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA,0CAA0C,gCAAgC;QAC1E;QACA;;QAEA;QACA;QACA;QACA,wDAAwD,kBAAkB;QAC1E;QACA,iDAAiD,cAAc;QAC/D;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,yCAAyC,iCAAiC;QAC1E,gHAAgH,mBAAmB,EAAE;QACrI;QACA;;QAEA;QACA;QACA;QACA,2BAA2B,0BAA0B,EAAE;QACvD,iCAAiC,eAAe;QAChD;QACA;QACA;;QAEA;QACA,sDAAsD,+DAA+D;;QAErH;QACA;;;QAGA;QACA;;;;;;;;;;;;AClFA;AACA;AACA;AACA;AACA;;AAEA,2BAA2B,mBAAO,CAAC,kDAAS;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA,YAAY,OAAO;AACnB;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;;;;;;;;;;;;;;ACjMA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,mBAAmB,mBAAO,CAAC,sCAAI;;AAE/B;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;;AAEA;AACA;AACA,cAAc;AACd;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,aAAa,SAAS;AACtB,4BAA4B;AAC5B;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA,aAAa,8BAA8B;AAC3C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,yCAAyC,SAAS;AAClD;AACA;AACA;AACA;AACA,yCAAyC,SAAS;AAClD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;;AChOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,qBAAqB;AACrE;;AAEA;AACA;AACA,+BAA+B,aAAa;AAC5C;;AAEA;AACA;AACA,+BAA+B,SAAS,cAAc;AACtD;;AAEA;AACA;AACA,+BAA+B,uBAAuB;AACtD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,+FAA+F;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,mBAAmB,qBAAqB;AACxC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,qGAAqG;AACrG;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,4CAA4C;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,qCAAqC;AACrC;AACA,GAAG;AACH;;AAEA;AACA,0BAA0B,cAAc;;AAExC,wBAAwB;AACxB,4BAA4B,sBAAsB;AAClD;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;;AC5PA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,cAAc;AACzB,WAAW,OAAO;AAClB,YAAY,MAAM;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACvJA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA,2BAA2B;AAC3B;AACA;AACA;AACA,4BAA4B,UAAU;;;;;;;;;;;;;ACvLtC;AACa;;AAEb;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB;AACpB,0BAA0B;AAC1B;AACA;AACA;AACA,yDAAyD;AACzD,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL,iDAAiD;AACjD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,kBAAkB,OAAO;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,YAAY;AACZ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,IAAI,IAA0B;AAC9B;AACA;;;;;;;;;;;;;;AC1qBA,IAAIA,KAAKC,mBAAOA,CAAC,wDAAR,CAAT;AACA,IAAIC,WAAWD,mBAAOA,CAAC,sCAAR,CAAf;AACA,IAAIE,QAAQF,mBAAOA,CAAC,kDAAR,EAAiB,yBAAjB,CAAZ;AACA,IAAIG,OAAOH,mBAAOA,CAAC,kDAAR,EAAiB,wBAAjB,CAAX;AACA,IAAII,QAAQJ,mBAAOA,CAAC,kDAAR,EAAiB,yBAAjB,CAAZ;AACA,IAAIK,WAAW,iCAAiCC,IAAjC,CAAsCC,UAAUC,SAAhD,CAAf;;AAEA,MAAMC,uBAAuB,KAA7B;;AAEA,MAAMC,gCAAgC,CAAt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","file":"naf-janus-adapter.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/index.js\");\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  '#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC',\n  '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF',\n  '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC',\n  '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF',\n  '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC',\n  '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033',\n  '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366',\n  '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933',\n  '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC',\n  '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF',\n  '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // NB: In an Electron preload script, document will be defined but not fully\n  // initialized. Since we know we're in Chrome, we'll just detect this case\n  // explicitly\n  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {\n    return true;\n  }\n\n  // Internet Explorer and Edge do not support colors.\n  if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n    return false;\n  }\n\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n    // double check webkit in userAgent just in case we are in a worker\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return;\n\n  var c = 'color: ' + this.color;\n  args.splice(1, 0, c, 'color: inherit')\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  var r;\n  try {\n    r = exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (!r && typeof process !== 'undefined' && 'env' in process) {\n    r = process.env.DEBUG;\n  }\n\n  return r;\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug['default'] = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * Active `debug` instances.\n */\nexports.instances = [];\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n  var hash = 0, i;\n\n  for (i in namespace) {\n    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n  var prevTime;\n\n  function debug() {\n    // disabled?\n    if (!debug.enabled) return;\n\n    var self = debug;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // turn the `arguments` into a proper Array\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %O\n      args.unshift('%O');\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting (colors, etc.)\n    exports.formatArgs.call(self, args);\n\n    var logFn = debug.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n\n  debug.namespace = namespace;\n  debug.enabled = exports.enabled(namespace);\n  debug.useColors = exports.useColors();\n  debug.color = selectColor(namespace);\n  debug.destroy = destroy;\n\n  // env-specific initialization logic for debug instances\n  if ('function' === typeof exports.init) {\n    exports.init(debug);\n  }\n\n  exports.instances.push(debug);\n\n  return debug;\n}\n\nfunction destroy () {\n  var index = exports.instances.indexOf(this);\n  if (index !== -1) {\n    exports.instances.splice(index, 1);\n    return true;\n  } else {\n    return false;\n  }\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  exports.names = [];\n  exports.skips = [];\n\n  var i;\n  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n\n  for (i = 0; i < exports.instances.length; i++) {\n    var instance = exports.instances[i];\n    instance.enabled = exports.enabled(instance.namespace);\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  if (name[name.length - 1] === '*') {\n    return true;\n  }\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n","/**\n * Represents a handle to a single Janus plugin on a Janus session. Each WebRTC connection to the Janus server will be\n * associated with a single handle. Once attached to the server, this handle will be given a unique ID which should be\n * used to associate it with future signalling messages.\n *\n * See https://janus.conf.meetecho.com/docs/rest.html#handles.\n **/\nfunction JanusPluginHandle(session) {\n  this.session = session;\n  this.id = undefined;\n}\n\n/** Attaches this handle to the Janus server and sets its ID. **/\nJanusPluginHandle.prototype.attach = function(plugin) {\n  var payload = { plugin: plugin, \"force-bundle\": true, \"force-rtcp-mux\": true };\n  return this.session.send(\"attach\", payload).then(resp => {\n    this.id = resp.data.id;\n    return resp;\n  });\n};\n\n/** Detaches this handle. **/\nJanusPluginHandle.prototype.detach = function() {\n  return this.send(\"detach\");\n};\n\n/** Registers a callback to be fired upon the reception of any incoming Janus signals for this plugin handle with the\n * `janus` attribute equal to `ev`.\n **/\nJanusPluginHandle.prototype.on = function(ev, callback) {\n  return this.session.on(ev, signal => {\n    if (signal.sender == this.id) {\n      callback(signal);\n    }\n  });\n};\n\n/**\n * Sends a signal associated with this handle. Signals should be JSON-serializable objects. Returns a promise that will\n * be resolved or rejected when a response to this signal is received, or when no response is received within the\n * session timeout.\n **/\nJanusPluginHandle.prototype.send = function(type, signal) {\n  return this.session.send(type, Object.assign({ handle_id: this.id }, signal));\n};\n\n/** Sends a plugin-specific message associated with this handle. **/\nJanusPluginHandle.prototype.sendMessage = function(body) {\n  return this.send(\"message\", { body: body });\n};\n\n/** Sends a JSEP offer or answer associated with this handle. **/\nJanusPluginHandle.prototype.sendJsep = function(jsep) {\n  return this.send(\"message\", { body: {}, jsep: jsep });\n};\n\n/** Sends an ICE trickle candidate associated with this handle. **/\nJanusPluginHandle.prototype.sendTrickle = function(candidate) {\n  return this.send(\"trickle\", { candidate: candidate });\n};\n\n/**\n * Represents a Janus session -- a Janus context from within which you can open multiple handles and connections. Once\n * created, this session will be given a unique ID which should be used to associate it with future signalling messages.\n *\n * See https://janus.conf.meetecho.com/docs/rest.html#sessions.\n **/\nfunction JanusSession(output, options) {\n  this.output = output;\n  this.id = undefined;\n  this.nextTxId = 0;\n  this.txns = {};\n  this.eventHandlers = {};\n  this.options = Object.assign({\n    verbose: false,\n    timeoutMs: 10000,\n    keepaliveMs: 30000\n  }, options);\n}\n\n/** Creates this session on the Janus server and sets its ID. **/\nJanusSession.prototype.create = function() {\n  return this.send(\"create\").then(resp => {\n    this.id = resp.data.id;\n    return resp;\n  });\n};\n\n/**\n * Destroys this session. Note that upon destruction, Janus will also close the signalling transport (if applicable) and\n * any open WebRTC connections.\n **/\nJanusSession.prototype.destroy = function() {\n  return this.send(\"destroy\").then((resp) => {\n    this.dispose();\n    return resp;\n  });\n};\n\n/**\n * Disposes of this session in a way such that no further incoming signalling messages will be processed.\n * Outstanding transactions will be rejected.\n **/\nJanusSession.prototype.dispose = function() {\n  this._killKeepalive();\n  this.eventHandlers = {};\n  for (var txId in this.txns) {\n    if (this.txns.hasOwnProperty(txId)) {\n      var txn = this.txns[txId];\n      clearTimeout(txn.timeout);\n      txn.reject(new Error(\"Janus session was disposed.\"));\n      delete this.txns[txId];\n    }\n  }\n};\n\n/**\n * Whether this signal represents an error, and the associated promise (if any) should be rejected.\n * Users should override this to handle any custom plugin-specific error conventions.\n **/\nJanusSession.prototype.isError = function(signal) {\n  return signal.janus === \"error\";\n};\n\n/** Registers a callback to be fired upon the reception of any incoming Janus signals for this session with the\n * `janus` attribute equal to `ev`.\n **/\nJanusSession.prototype.on = function(ev, callback) {\n  var handlers = this.eventHandlers[ev];\n  if (handlers == null) {\n    handlers = this.eventHandlers[ev] = [];\n  }\n  handlers.push(callback);\n};\n\n/**\n * Callback for receiving JSON signalling messages pertinent to this session. If the signals are responses to previously\n * sent signals, the promises for the outgoing signals will be resolved or rejected appropriately with this signal as an\n * argument.\n *\n * External callers should call this function every time a new signal arrives on the transport; for example, in a\n * WebSocket's `message` event, or when a new datum shows up in an HTTP long-polling response.\n **/\nJanusSession.prototype.receive = function(signal) {\n  if (this.options.verbose) {\n    this._logIncoming(signal);\n  }\n  if (signal.session_id != this.id) {\n    console.warn(\"Incorrect session ID received in Janus signalling message: was \" + signal.session_id + \", expected \" + this.id + \".\");\n  }\n\n  var responseType = signal.janus;\n  var handlers = this.eventHandlers[responseType];\n  if (handlers != null) {\n    for (var i = 0; i < handlers.length; i++) {\n      handlers[i](signal);\n    }\n  }\n\n  if (signal.transaction != null) {\n    var txn = this.txns[signal.transaction];\n    if (txn == null) {\n      // this is a response to a transaction that wasn't caused via JanusSession.send, or a plugin replied twice to a\n      // single request, or the session was disposed, or something else that isn't under our purview; that's fine\n      return;\n    }\n\n    if (responseType === \"ack\" && txn.type == \"message\") {\n      // this is an ack of an asynchronously-processed plugin request, we should wait to resolve the promise until the\n      // actual response comes in\n      return;\n    }\n\n    clearTimeout(txn.timeout);\n\n    delete this.txns[signal.transaction];\n    (this.isError(signal) ? txn.reject : txn.resolve)(signal);\n  }\n};\n\n/**\n * Sends a signal associated with this session, beginning a new transaction. Returns a promise that will be resolved or\n * rejected when a response is received in the same transaction, or when no response is received within the session\n * timeout.\n **/\nJanusSession.prototype.send = function(type, signal) {\n  signal = Object.assign({ transaction: (this.nextTxId++).toString() }, signal);\n  return new Promise((resolve, reject) => {\n    var timeout = null;\n    if (this.options.timeoutMs) {\n      timeout = setTimeout(() => {\n        delete this.txns[signal.transaction];\n        reject(new Error(\"Signalling transaction with txid \" + signal.transaction + \" timed out.\"));\n      }, this.options.timeoutMs);\n    }\n    this.txns[signal.transaction] = { resolve: resolve, reject: reject, timeout: timeout, type: type };\n    this._transmit(type, signal);\n  });\n};\n\nJanusSession.prototype._transmit = function(type, signal) {\n  signal = Object.assign({ janus: type }, signal);\n\n  if (this.id != null) { // this.id is undefined in the special case when we're sending the session create message\n    signal = Object.assign({ session_id: this.id }, signal);\n  }\n\n  if (this.options.verbose) {\n    this._logOutgoing(signal);\n  }\n\n  this.output(JSON.stringify(signal));\n  this._resetKeepalive();\n};\n\nJanusSession.prototype._logOutgoing = function(signal) {\n  var kind = signal.janus;\n  if (kind === \"message\" && signal.jsep) {\n    kind = signal.jsep.type;\n  }\n  var message = \"> Outgoing Janus \" + (kind || \"signal\") + \" (#\" + signal.transaction + \"): \";\n  console.debug(\"%c\" + message, \"color: #040\", signal);\n};\n\nJanusSession.prototype._logIncoming = function(signal) {\n  var kind = signal.janus;\n  var message = signal.transaction ?\n      \"< Incoming Janus \" + (kind || \"signal\") + \" (#\" + signal.transaction + \"): \" :\n      \"< Incoming Janus \" + (kind || \"signal\") + \": \";\n  console.debug(\"%c\" + message, \"color: #004\", signal);\n};\n\nJanusSession.prototype._sendKeepalive = function() {\n  return this.send(\"keepalive\");\n};\n\nJanusSession.prototype._killKeepalive = function() {\n  clearTimeout(this.keepaliveTimeout);\n};\n\nJanusSession.prototype._resetKeepalive = function() {\n  this._killKeepalive();\n  if (this.options.keepaliveMs) {\n    this.keepaliveTimeout = setTimeout(() => {\n      this._sendKeepalive().catch(e => console.error(\"Error received from keepalive: \", e));\n    }, this.options.keepaliveMs);\n  }\n};\n\nmodule.exports = {\n  JanusPluginHandle,\n  JanusSession\n};\n","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return;\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name;\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's';\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n"," /* eslint-env node */\n'use strict';\n\n// SDP helpers.\nvar SDPUtils = {};\n\n// Generate an alphanumeric identifier for cname or mids.\n// TODO: use UUIDs instead? https://gist.github.com/jed/982883\nSDPUtils.generateIdentifier = function() {\n  return Math.random().toString(36).substr(2, 10);\n};\n\n// The RTCP CNAME used by all peerconnections from the same JS.\nSDPUtils.localCName = SDPUtils.generateIdentifier();\n\n// Splits SDP into lines, dealing with both CRLF and LF.\nSDPUtils.splitLines = function(blob) {\n  return blob.trim().split('\\n').map(function(line) {\n    return line.trim();\n  });\n};\n// Splits SDP into sessionpart and mediasections. Ensures CRLF.\nSDPUtils.splitSections = function(blob) {\n  var parts = blob.split('\\nm=');\n  return parts.map(function(part, index) {\n    return (index > 0 ? 'm=' + part : part).trim() + '\\r\\n';\n  });\n};\n\n// returns the session description.\nSDPUtils.getDescription = function(blob) {\n  var sections = SDPUtils.splitSections(blob);\n  return sections && sections[0];\n};\n\n// returns the individual media sections.\nSDPUtils.getMediaSections = function(blob) {\n  var sections = SDPUtils.splitSections(blob);\n  sections.shift();\n  return sections;\n};\n\n// Returns lines that start with a certain prefix.\nSDPUtils.matchPrefix = function(blob, prefix) {\n  return SDPUtils.splitLines(blob).filter(function(line) {\n    return line.indexOf(prefix) === 0;\n  });\n};\n\n// Parses an ICE candidate line. Sample input:\n// candidate:702786350 2 udp 41819902 8.8.8.8 60769 typ relay raddr 8.8.8.8\n// rport 55996\"\nSDPUtils.parseCandidate = function(line) {\n  var parts;\n  // Parse both variants.\n  if (line.indexOf('a=candidate:') === 0) {\n    parts = line.substring(12).split(' ');\n  } else {\n    parts = line.substring(10).split(' ');\n  }\n\n  var candidate = {\n    foundation: parts[0],\n    component: parseInt(parts[1], 10),\n    protocol: parts[2].toLowerCase(),\n    priority: parseInt(parts[3], 10),\n    ip: parts[4],\n    port: parseInt(parts[5], 10),\n    // skip parts[6] == 'typ'\n    type: parts[7]\n  };\n\n  for (var i = 8; i < parts.length; i += 2) {\n    switch (parts[i]) {\n      case 'raddr':\n        candidate.relatedAddress = parts[i + 1];\n        break;\n      case 'rport':\n        candidate.relatedPort = parseInt(parts[i + 1], 10);\n        break;\n      case 'tcptype':\n        candidate.tcpType = parts[i + 1];\n        break;\n      case 'ufrag':\n        candidate.ufrag = parts[i + 1]; // for backward compability.\n        candidate.usernameFragment = parts[i + 1];\n        break;\n      default: // extension handling, in particular ufrag\n        candidate[parts[i]] = parts[i + 1];\n        break;\n    }\n  }\n  return candidate;\n};\n\n// Translates a candidate object into SDP candidate attribute.\nSDPUtils.writeCandidate = function(candidate) {\n  var sdp = [];\n  sdp.push(candidate.foundation);\n  sdp.push(candidate.component);\n  sdp.push(candidate.protocol.toUpperCase());\n  sdp.push(candidate.priority);\n  sdp.push(candidate.ip);\n  sdp.push(candidate.port);\n\n  var type = candidate.type;\n  sdp.push('typ');\n  sdp.push(type);\n  if (type !== 'host' && candidate.relatedAddress &&\n      candidate.relatedPort) {\n    sdp.push('raddr');\n    sdp.push(candidate.relatedAddress);\n    sdp.push('rport');\n    sdp.push(candidate.relatedPort);\n  }\n  if (candidate.tcpType && candidate.protocol.toLowerCase() === 'tcp') {\n    sdp.push('tcptype');\n    sdp.push(candidate.tcpType);\n  }\n  if (candidate.usernameFragment || candidate.ufrag) {\n    sdp.push('ufrag');\n    sdp.push(candidate.usernameFragment || candidate.ufrag);\n  }\n  return 'candidate:' + sdp.join(' ');\n};\n\n// Parses an ice-options line, returns an array of option tags.\n// a=ice-options:foo bar\nSDPUtils.parseIceOptions = function(line) {\n  return line.substr(14).split(' ');\n}\n\n// Parses an rtpmap line, returns RTCRtpCoddecParameters. Sample input:\n// a=rtpmap:111 opus/48000/2\nSDPUtils.parseRtpMap = function(line) {\n  var parts = line.substr(9).split(' ');\n  var parsed = {\n    payloadType: parseInt(parts.shift(), 10) // was: id\n  };\n\n  parts = parts[0].split('/');\n\n  parsed.name = parts[0];\n  parsed.clockRate = parseInt(parts[1], 10); // was: clockrate\n  parsed.channels = parts.length === 3 ? parseInt(parts[2], 10) : 1;\n  // legacy alias, got renamed back to channels in ORTC.\n  parsed.numChannels = parsed.channels;\n  return parsed;\n};\n\n// Generate an a=rtpmap line from RTCRtpCodecCapability or\n// RTCRtpCodecParameters.\nSDPUtils.writeRtpMap = function(codec) {\n  var pt = codec.payloadType;\n  if (codec.preferredPayloadType !== undefined) {\n    pt = codec.preferredPayloadType;\n  }\n  var channels = codec.channels || codec.numChannels || 1;\n  return 'a=rtpmap:' + pt + ' ' + codec.name + '/' + codec.clockRate +\n      (channels !== 1 ? '/' + channels : '') + '\\r\\n';\n};\n\n// Parses an a=extmap line (headerextension from RFC 5285). Sample input:\n// a=extmap:2 urn:ietf:params:rtp-hdrext:toffset\n// a=extmap:2/sendonly urn:ietf:params:rtp-hdrext:toffset\nSDPUtils.parseExtmap = function(line) {\n  var parts = line.substr(9).split(' ');\n  return {\n    id: parseInt(parts[0], 10),\n    direction: parts[0].indexOf('/') > 0 ? parts[0].split('/')[1] : 'sendrecv',\n    uri: parts[1]\n  };\n};\n\n// Generates a=extmap line from RTCRtpHeaderExtensionParameters or\n// RTCRtpHeaderExtension.\nSDPUtils.writeExtmap = function(headerExtension) {\n  return 'a=extmap:' + (headerExtension.id || headerExtension.preferredId) +\n      (headerExtension.direction && headerExtension.direction !== 'sendrecv'\n          ? '/' + headerExtension.direction\n          : '') +\n      ' ' + headerExtension.uri + '\\r\\n';\n};\n\n// Parses an ftmp line, returns dictionary. Sample input:\n// a=fmtp:96 vbr=on;cng=on\n// Also deals with vbr=on; cng=on\nSDPUtils.parseFmtp = function(line) {\n  var parsed = {};\n  var kv;\n  var parts = line.substr(line.indexOf(' ') + 1).split(';');\n  for (var j = 0; j < parts.length; j++) {\n    kv = parts[j].trim().split('=');\n    parsed[kv[0].trim()] = kv[1];\n  }\n  return parsed;\n};\n\n// Generates an a=ftmp line from RTCRtpCodecCapability or RTCRtpCodecParameters.\nSDPUtils.writeFmtp = function(codec) {\n  var line = '';\n  var pt = codec.payloadType;\n  if (codec.preferredPayloadType !== undefined) {\n    pt = codec.preferredPayloadType;\n  }\n  if (codec.parameters && Object.keys(codec.parameters).length) {\n    var params = [];\n    Object.keys(codec.parameters).forEach(function(param) {\n      if (codec.parameters[param]) {\n        params.push(param + '=' + codec.parameters[param]);\n      } else {\n        params.push(param);\n      }\n    });\n    line += 'a=fmtp:' + pt + ' ' + params.join(';') + '\\r\\n';\n  }\n  return line;\n};\n\n// Parses an rtcp-fb line, returns RTCPRtcpFeedback object. Sample input:\n// a=rtcp-fb:98 nack rpsi\nSDPUtils.parseRtcpFb = function(line) {\n  var parts = line.substr(line.indexOf(' ') + 1).split(' ');\n  return {\n    type: parts.shift(),\n    parameter: parts.join(' ')\n  };\n};\n// Generate a=rtcp-fb lines from RTCRtpCodecCapability or RTCRtpCodecParameters.\nSDPUtils.writeRtcpFb = function(codec) {\n  var lines = '';\n  var pt = codec.payloadType;\n  if (codec.preferredPayloadType !== undefined) {\n    pt = codec.preferredPayloadType;\n  }\n  if (codec.rtcpFeedback && codec.rtcpFeedback.length) {\n    // FIXME: special handling for trr-int?\n    codec.rtcpFeedback.forEach(function(fb) {\n      lines += 'a=rtcp-fb:' + pt + ' ' + fb.type +\n      (fb.parameter && fb.parameter.length ? ' ' + fb.parameter : '') +\n          '\\r\\n';\n    });\n  }\n  return lines;\n};\n\n// Parses an RFC 5576 ssrc media attribute. Sample input:\n// a=ssrc:3735928559 cname:something\nSDPUtils.parseSsrcMedia = function(line) {\n  var sp = line.indexOf(' ');\n  var parts = {\n    ssrc: parseInt(line.substr(7, sp - 7), 10)\n  };\n  var colon = line.indexOf(':', sp);\n  if (colon > -1) {\n    parts.attribute = line.substr(sp + 1, colon - sp - 1);\n    parts.value = line.substr(colon + 1);\n  } else {\n    parts.attribute = line.substr(sp + 1);\n  }\n  return parts;\n};\n\n// Extracts the MID (RFC 5888) from a media section.\n// returns the MID or undefined if no mid line was found.\nSDPUtils.getMid = function(mediaSection) {\n  var mid = SDPUtils.matchPrefix(mediaSection, 'a=mid:')[0];\n  if (mid) {\n    return mid.substr(6);\n  }\n}\n\nSDPUtils.parseFingerprint = function(line) {\n  var parts = line.substr(14).split(' ');\n  return {\n    algorithm: parts[0].toLowerCase(), // algorithm is case-sensitive in Edge.\n    value: parts[1]\n  };\n};\n\n// Extracts DTLS parameters from SDP media section or sessionpart.\n// FIXME: for consistency with other functions this should only\n//   get the fingerprint line as input. See also getIceParameters.\nSDPUtils.getDtlsParameters = function(mediaSection, sessionpart) {\n  var lines = SDPUtils.matchPrefix(mediaSection + sessionpart,\n      'a=fingerprint:');\n  // Note: a=setup line is ignored since we use the 'auto' role.\n  // Note2: 'algorithm' is not case sensitive except in Edge.\n  return {\n    role: 'auto',\n    fingerprints: lines.map(SDPUtils.parseFingerprint)\n  };\n};\n\n// Serializes DTLS parameters to SDP.\nSDPUtils.writeDtlsParameters = function(params, setupType) {\n  var sdp = 'a=setup:' + setupType + '\\r\\n';\n  params.fingerprints.forEach(function(fp) {\n    sdp += 'a=fingerprint:' + fp.algorithm + ' ' + fp.value + '\\r\\n';\n  });\n  return sdp;\n};\n// Parses ICE information from SDP media section or sessionpart.\n// FIXME: for consistency with other functions this should only\n//   get the ice-ufrag and ice-pwd lines as input.\nSDPUtils.getIceParameters = function(mediaSection, sessionpart) {\n  var lines = SDPUtils.splitLines(mediaSection);\n  // Search in session part, too.\n  lines = lines.concat(SDPUtils.splitLines(sessionpart));\n  var iceParameters = {\n    usernameFragment: lines.filter(function(line) {\n      return line.indexOf('a=ice-ufrag:') === 0;\n    })[0].substr(12),\n    password: lines.filter(function(line) {\n      return line.indexOf('a=ice-pwd:') === 0;\n    })[0].substr(10)\n  };\n  return iceParameters;\n};\n\n// Serializes ICE parameters to SDP.\nSDPUtils.writeIceParameters = function(params) {\n  return 'a=ice-ufrag:' + params.usernameFragment + '\\r\\n' +\n      'a=ice-pwd:' + params.password + '\\r\\n';\n};\n\n// Parses the SDP media section and returns RTCRtpParameters.\nSDPUtils.parseRtpParameters = function(mediaSection) {\n  var description = {\n    codecs: [],\n    headerExtensions: [],\n    fecMechanisms: [],\n    rtcp: []\n  };\n  var lines = SDPUtils.splitLines(mediaSection);\n  var mline = lines[0].split(' ');\n  for (var i = 3; i < mline.length; i++) { // find all codecs from mline[3..]\n    var pt = mline[i];\n    var rtpmapline = SDPUtils.matchPrefix(\n        mediaSection, 'a=rtpmap:' + pt + ' ')[0];\n    if (rtpmapline) {\n      var codec = SDPUtils.parseRtpMap(rtpmapline);\n      var fmtps = SDPUtils.matchPrefix(\n          mediaSection, 'a=fmtp:' + pt + ' ');\n      // Only the first a=fmtp:<pt> is considered.\n      codec.parameters = fmtps.length ? SDPUtils.parseFmtp(fmtps[0]) : {};\n      codec.rtcpFeedback = SDPUtils.matchPrefix(\n          mediaSection, 'a=rtcp-fb:' + pt + ' ')\n        .map(SDPUtils.parseRtcpFb);\n      description.codecs.push(codec);\n      // parse FEC mechanisms from rtpmap lines.\n      switch (codec.name.toUpperCase()) {\n        case 'RED':\n        case 'ULPFEC':\n          description.fecMechanisms.push(codec.name.toUpperCase());\n          break;\n        default: // only RED and ULPFEC are recognized as FEC mechanisms.\n          break;\n      }\n    }\n  }\n  SDPUtils.matchPrefix(mediaSection, 'a=extmap:').forEach(function(line) {\n    description.headerExtensions.push(SDPUtils.parseExtmap(line));\n  });\n  // FIXME: parse rtcp.\n  return description;\n};\n\n// Generates parts of the SDP media section describing the capabilities /\n// parameters.\nSDPUtils.writeRtpDescription = function(kind, caps) {\n  var sdp = '';\n\n  // Build the mline.\n  sdp += 'm=' + kind + ' ';\n  sdp += caps.codecs.length > 0 ? '9' : '0'; // reject if no codecs.\n  sdp += ' UDP/TLS/RTP/SAVPF ';\n  sdp += caps.codecs.map(function(codec) {\n    if (codec.preferredPayloadType !== undefined) {\n      return codec.preferredPayloadType;\n    }\n    return codec.payloadType;\n  }).join(' ') + '\\r\\n';\n\n  sdp += 'c=IN IP4 0.0.0.0\\r\\n';\n  sdp += 'a=rtcp:9 IN IP4 0.0.0.0\\r\\n';\n\n  // Add a=rtpmap lines for each codec. Also fmtp and rtcp-fb.\n  caps.codecs.forEach(function(codec) {\n    sdp += SDPUtils.writeRtpMap(codec);\n    sdp += SDPUtils.writeFmtp(codec);\n    sdp += SDPUtils.writeRtcpFb(codec);\n  });\n  var maxptime = 0;\n  caps.codecs.forEach(function(codec) {\n    if (codec.maxptime > maxptime) {\n      maxptime = codec.maxptime;\n    }\n  });\n  if (maxptime > 0) {\n    sdp += 'a=maxptime:' + maxptime + '\\r\\n';\n  }\n  sdp += 'a=rtcp-mux\\r\\n';\n\n  if (caps.headerExtensions) {\n    caps.headerExtensions.forEach(function(extension) {\n      sdp += SDPUtils.writeExtmap(extension);\n    });\n  }\n  // FIXME: write fecMechanisms.\n  return sdp;\n};\n\n// Parses the SDP media section and returns an array of\n// RTCRtpEncodingParameters.\nSDPUtils.parseRtpEncodingParameters = function(mediaSection) {\n  var encodingParameters = [];\n  var description = SDPUtils.parseRtpParameters(mediaSection);\n  var hasRed = description.fecMechanisms.indexOf('RED') !== -1;\n  var hasUlpfec = description.fecMechanisms.indexOf('ULPFEC') !== -1;\n\n  // filter a=ssrc:... cname:, ignore PlanB-msid\n  var ssrcs = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')\n  .map(function(line) {\n    return SDPUtils.parseSsrcMedia(line);\n  })\n  .filter(function(parts) {\n    return parts.attribute === 'cname';\n  });\n  var primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;\n  var secondarySsrc;\n\n  var flows = SDPUtils.matchPrefix(mediaSection, 'a=ssrc-group:FID')\n  .map(function(line) {\n    var parts = line.substr(17).split(' ');\n    return parts.map(function(part) {\n      return parseInt(part, 10);\n    });\n  });\n  if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {\n    secondarySsrc = flows[0][1];\n  }\n\n  description.codecs.forEach(function(codec) {\n    if (codec.name.toUpperCase() === 'RTX' && codec.parameters.apt) {\n      var encParam = {\n        ssrc: primarySsrc,\n        codecPayloadType: parseInt(codec.parameters.apt, 10),\n      };\n      if (primarySsrc && secondarySsrc) {\n        encParam.rtx = {ssrc: secondarySsrc};\n      }\n      encodingParameters.push(encParam);\n      if (hasRed) {\n        encParam = JSON.parse(JSON.stringify(encParam));\n        encParam.fec = {\n          ssrc: secondarySsrc,\n          mechanism: hasUlpfec ? 'red+ulpfec' : 'red'\n        };\n        encodingParameters.push(encParam);\n      }\n    }\n  });\n  if (encodingParameters.length === 0 && primarySsrc) {\n    encodingParameters.push({\n      ssrc: primarySsrc\n    });\n  }\n\n  // we support both b=AS and b=TIAS but interpret AS as TIAS.\n  var bandwidth = SDPUtils.matchPrefix(mediaSection, 'b=');\n  if (bandwidth.length) {\n    if (bandwidth[0].indexOf('b=TIAS:') === 0) {\n      bandwidth = parseInt(bandwidth[0].substr(7), 10);\n    } else if (bandwidth[0].indexOf('b=AS:') === 0) {\n      // use formula from JSEP to convert b=AS to TIAS value.\n      bandwidth = parseInt(bandwidth[0].substr(5), 10) * 1000 * 0.95\n          - (50 * 40 * 8);\n    } else {\n      bandwidth = undefined;\n    }\n    encodingParameters.forEach(function(params) {\n      params.maxBitrate = bandwidth;\n    });\n  }\n  return encodingParameters;\n};\n\n// parses http://draft.ortc.org/#rtcrtcpparameters*\nSDPUtils.parseRtcpParameters = function(mediaSection) {\n  var rtcpParameters = {};\n\n  var cname;\n  // Gets the first SSRC. Note that with RTX there might be multiple\n  // SSRCs.\n  var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')\n      .map(function(line) {\n        return SDPUtils.parseSsrcMedia(line);\n      })\n      .filter(function(obj) {\n        return obj.attribute === 'cname';\n      })[0];\n  if (remoteSsrc) {\n    rtcpParameters.cname = remoteSsrc.value;\n    rtcpParameters.ssrc = remoteSsrc.ssrc;\n  }\n\n  // Edge uses the compound attribute instead of reducedSize\n  // compound is !reducedSize\n  var rsize = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-rsize');\n  rtcpParameters.reducedSize = rsize.length > 0;\n  rtcpParameters.compound = rsize.length === 0;\n\n  // parses the rtcp-mux attrіbute.\n  // Note that Edge does not support unmuxed RTCP.\n  var mux = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-mux');\n  rtcpParameters.mux = mux.length > 0;\n\n  return rtcpParameters;\n};\n\n// parses either a=msid: or a=ssrc:... msid lines and returns\n// the id of the MediaStream and MediaStreamTrack.\nSDPUtils.parseMsid = function(mediaSection) {\n  var parts;\n  var spec = SDPUtils.matchPrefix(mediaSection, 'a=msid:');\n  if (spec.length === 1) {\n    parts = spec[0].substr(7).split(' ');\n    return {stream: parts[0], track: parts[1]};\n  }\n  var planB = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')\n  .map(function(line) {\n    return SDPUtils.parseSsrcMedia(line);\n  })\n  .filter(function(parts) {\n    return parts.attribute === 'msid';\n  });\n  if (planB.length > 0) {\n    parts = planB[0].value.split(' ');\n    return {stream: parts[0], track: parts[1]};\n  }\n};\n\n// Generate a session ID for SDP.\n// https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-20#section-5.2.1\n// recommends using a cryptographically random +ve 64-bit value\n// but right now this should be acceptable and within the right range\nSDPUtils.generateSessionId = function() {\n  return Math.random().toString().substr(2, 21);\n};\n\n// Write boilder plate for start of SDP\n// sessId argument is optional - if not supplied it will\n// be generated randomly\n// sessVersion is optional and defaults to 2\nSDPUtils.writeSessionBoilerplate = function(sessId, sessVer) {\n  var sessionId;\n  var version = sessVer !== undefined ? sessVer : 2;\n  if (sessId) {\n    sessionId = sessId;\n  } else {\n    sessionId = SDPUtils.generateSessionId();\n  }\n  // FIXME: sess-id should be an NTP timestamp.\n  return 'v=0\\r\\n' +\n      'o=thisisadapterortc ' + sessionId + ' ' + version + ' IN IP4 127.0.0.1\\r\\n' +\n      's=-\\r\\n' +\n      't=0 0\\r\\n';\n};\n\nSDPUtils.writeMediaSection = function(transceiver, caps, type, stream) {\n  var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);\n\n  // Map ICE parameters (ufrag, pwd) to SDP.\n  sdp += SDPUtils.writeIceParameters(\n      transceiver.iceGatherer.getLocalParameters());\n\n  // Map DTLS parameters to SDP.\n  sdp += SDPUtils.writeDtlsParameters(\n      transceiver.dtlsTransport.getLocalParameters(),\n      type === 'offer' ? 'actpass' : 'active');\n\n  sdp += 'a=mid:' + transceiver.mid + '\\r\\n';\n\n  if (transceiver.direction) {\n    sdp += 'a=' + transceiver.direction + '\\r\\n';\n  } else if (transceiver.rtpSender && transceiver.rtpReceiver) {\n    sdp += 'a=sendrecv\\r\\n';\n  } else if (transceiver.rtpSender) {\n    sdp += 'a=sendonly\\r\\n';\n  } else if (transceiver.rtpReceiver) {\n    sdp += 'a=recvonly\\r\\n';\n  } else {\n    sdp += 'a=inactive\\r\\n';\n  }\n\n  if (transceiver.rtpSender) {\n    // spec.\n    var msid = 'msid:' + stream.id + ' ' +\n        transceiver.rtpSender.track.id + '\\r\\n';\n    sdp += 'a=' + msid;\n\n    // for Chrome.\n    sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +\n        ' ' + msid;\n    if (transceiver.sendEncodingParameters[0].rtx) {\n      sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +\n          ' ' + msid;\n      sdp += 'a=ssrc-group:FID ' +\n          transceiver.sendEncodingParameters[0].ssrc + ' ' +\n          transceiver.sendEncodingParameters[0].rtx.ssrc +\n          '\\r\\n';\n    }\n  }\n  // FIXME: this should be written by writeRtpDescription.\n  sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +\n      ' cname:' + SDPUtils.localCName + '\\r\\n';\n  if (transceiver.rtpSender && transceiver.sendEncodingParameters[0].rtx) {\n    sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +\n        ' cname:' + SDPUtils.localCName + '\\r\\n';\n  }\n  return sdp;\n};\n\n// Gets the direction from the mediaSection or the sessionpart.\nSDPUtils.getDirection = function(mediaSection, sessionpart) {\n  // Look for sendrecv, sendonly, recvonly, inactive, default to sendrecv.\n  var lines = SDPUtils.splitLines(mediaSection);\n  for (var i = 0; i < lines.length; i++) {\n    switch (lines[i]) {\n      case 'a=sendrecv':\n      case 'a=sendonly':\n      case 'a=recvonly':\n      case 'a=inactive':\n        return lines[i].substr(2);\n      default:\n        // FIXME: What should happen here?\n    }\n  }\n  if (sessionpart) {\n    return SDPUtils.getDirection(sessionpart);\n  }\n  return 'sendrecv';\n};\n\nSDPUtils.getKind = function(mediaSection) {\n  var lines = SDPUtils.splitLines(mediaSection);\n  var mline = lines[0].split(' ');\n  return mline[0].substr(2);\n};\n\nSDPUtils.isRejected = function(mediaSection) {\n  return mediaSection.split(' ', 2)[1] === '0';\n};\n\nSDPUtils.parseMLine = function(mediaSection) {\n  var lines = SDPUtils.splitLines(mediaSection);\n  var parts = lines[0].substr(2).split(' ');\n  return {\n    kind: parts[0],\n    port: parseInt(parts[1], 10),\n    protocol: parts[2],\n    fmt: parts.slice(3).join(' ')\n  };\n};\n\nSDPUtils.parseOLine = function(mediaSection) {\n  var line = SDPUtils.matchPrefix(mediaSection, 'o=')[0];\n  var parts = line.substr(2).split(' ');\n  return {\n    username: parts[0],\n    sessionId: parts[1],\n    sessionVersion: parseInt(parts[2], 10),\n    netType: parts[3],\n    addressType: parts[4],\n    address: parts[5],\n  };\n}\n\n// Expose public methods.\nif (typeof module === 'object') {\n  module.exports = SDPUtils;\n}\n","var mj = require(\"minijanus\");\nvar sdpUtils = require(\"sdp\");\nvar debug = require(\"debug\")(\"naf-janus-adapter:debug\");\nvar warn = require(\"debug\")(\"naf-janus-adapter:warn\");\nvar error = require(\"debug\")(\"naf-janus-adapter:error\");\nvar isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);\n\nconst SUBSCRIBE_TIMEOUT_MS = 15000;\n\nconst AVAILABLE_OCCUPANTS_THRESHOLD = 5;\nconst MAX_SUBSCRIBE_DELAY = 5000;\n\nfunction randomDelay(min, max) {\n  return new Promise(resolve => {\n    const delay = Math.random() * (max - min) + min;\n    setTimeout(resolve, delay);\n  });\n}\n\nfunction debounce(fn) {\n  var curr = Promise.resolve();\n  return function() {\n    var args = Array.prototype.slice.call(arguments);\n    curr = curr.then(_ => fn.apply(this, args));\n  };\n}\n\nfunction randomUint() {\n  return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);\n}\n\nfunction untilDataChannelOpen(dataChannel) {\n  return new Promise((resolve, reject) => {\n    if (dataChannel.readyState === \"open\") {\n      resolve();\n    } else {\n      let resolver, rejector;\n\n      const clear = () => {\n        dataChannel.removeEventListener(\"open\", resolver);\n        dataChannel.removeEventListener(\"error\", rejector);\n      };\n\n      resolver = () => {\n        clear();\n        resolve();\n      };\n      rejector = () => {\n        clear();\n        reject();\n      };\n\n      dataChannel.addEventListener(\"open\", resolver);\n      dataChannel.addEventListener(\"error\", rejector);\n    }\n  });\n}\n\nconst isH264VideoSupported = (() => {\n  const video = document.createElement(\"video\");\n  return video.canPlayType('video/mp4; codecs=\"avc1.42E01E, mp4a.40.2\"') !== \"\";\n})();\n\nconst OPUS_PARAMETERS = {\n  // indicates that we want to enable DTX to elide silence packets\n  usedtx: 1,\n  // indicates that we prefer to receive mono audio (important for voip profile)\n  stereo: 0,\n  // indicates that we prefer to send mono audio (important for voip profile)\n  \"sprop-stereo\": 0\n};\n\nconst DEFAULT_PEER_CONNECTION_CONFIG = {\n  iceServers: [{ urls: \"stun:stun1.l.google.com:19302\" }, { urls: \"stun:stun2.l.google.com:19302\" }]\n};\n\nconst WS_NORMAL_CLOSURE = 1000;\n\nclass JanusAdapter {\n  constructor() {\n    this.room = null;\n    // We expect the consumer to set a client id before connecting.\n    this.clientId = null;\n    this.joinToken = null;\n\n    this.serverUrl = null;\n    this.webRtcOptions = {};\n    this.peerConnectionConfig = null;\n    this.ws = null;\n    this.session = null;\n    this.reliableTransport = \"datachannel\";\n    this.unreliableTransport = \"datachannel\";\n\n    // In the event the server restarts and all clients lose connection, reconnect with\n    // some random jitter added to prevent simultaneous reconnection requests.\n    this.initialReconnectionDelay = 1000 * Math.random();\n    this.reconnectionDelay = this.initialReconnectionDelay;\n    this.reconnectionTimeout = null;\n    this.maxReconnectionAttempts = 10;\n    this.reconnectionAttempts = 0;\n\n    this.publisher = null;\n    this.occupantIds = [];\n    this.occupants = {};\n    this.mediaStreams = {};\n    this.localMediaStream = null;\n    this.pendingMediaRequests = new Map();\n\n    this.pendingOccupants = new Set();\n    this.availableOccupants = [];\n    this.requestedOccupants = null;\n\n    this.blockedClients = new Map();\n    this.frozenUpdates = new Map();\n\n    this.timeOffsets = [];\n    this.serverTimeRequests = 0;\n    this.avgTimeOffset = 0;\n\n    this.onWebsocketOpen = this.onWebsocketOpen.bind(this);\n    this.onWebsocketClose = this.onWebsocketClose.bind(this);\n    this.onWebsocketMessage = this.onWebsocketMessage.bind(this);\n    this.onDataChannelMessage = this.onDataChannelMessage.bind(this);\n    this.onData = this.onData.bind(this);\n  }\n\n  setServerUrl(url) {\n    this.serverUrl = url;\n  }\n\n  setApp(app) {}\n\n  setRoom(roomName) {\n    this.room = roomName;\n  }\n\n  setJoinToken(joinToken) {\n    this.joinToken = joinToken;\n  }\n\n  setClientId(clientId) {\n    this.clientId = clientId;\n  }\n\n  setWebRtcOptions(options) {\n    this.webRtcOptions = options;\n  }\n\n  setPeerConnectionConfig(peerConnectionConfig) {\n    this.peerConnectionConfig = peerConnectionConfig;\n  }\n\n  setServerConnectListeners(successListener, failureListener) {\n    this.connectSuccess = successListener;\n    this.connectFailure = failureListener;\n  }\n\n  setRoomOccupantListener(occupantListener) {\n    this.onOccupantsChanged = occupantListener;\n  }\n\n  setDataChannelListeners(openListener, closedListener, messageListener) {\n    this.onOccupantConnected = openListener;\n    this.onOccupantDisconnected = closedListener;\n    this.onOccupantMessage = messageListener;\n  }\n\n  setReconnectionListeners(reconnectingListener, reconnectedListener, reconnectionErrorListener) {\n    // onReconnecting is called with the number of milliseconds until the next reconnection attempt\n    this.onReconnecting = reconnectingListener;\n    // onReconnected is called when the connection has been reestablished\n    this.onReconnected = reconnectedListener;\n    // onReconnectionError is called with an error when maxReconnectionAttempts has been reached\n    this.onReconnectionError = reconnectionErrorListener;\n  }\n\n  connect() {\n    debug(`connecting to ${this.serverUrl}`);\n\n    const websocketConnection = new Promise((resolve, reject) => {\n      this.ws = new WebSocket(this.serverUrl, \"janus-protocol\");\n\n      this.session = new mj.JanusSession(this.ws.send.bind(this.ws), { timeoutMs: 30000 });\n\n      let onOpen;\n\n      const onError = () => {\n        reject(error);\n      };\n\n      this.ws.addEventListener(\"close\", this.onWebsocketClose);\n      this.ws.addEventListener(\"message\", this.onWebsocketMessage);\n\n      onOpen = () => {\n        this.ws.removeEventListener(\"open\", onOpen);\n        this.ws.removeEventListener(\"error\", onError);\n        this.onWebsocketOpen()\n          .then(resolve)\n          .catch(reject);\n      };\n\n      this.ws.addEventListener(\"open\", onOpen);\n    });\n\n    return Promise.all([websocketConnection, this.updateTimeOffset()]);\n  }\n\n  disconnect() {\n    debug(`disconnecting`);\n\n    clearTimeout(this.reconnectionTimeout);\n\n    this.removeAllOccupants();\n\n    if (this.publisher) {\n      // Close the publisher peer connection. Which also detaches the plugin handle.\n      this.publisher.conn.close();\n      this.publisher = null;\n    }\n\n    if (this.session) {\n      this.session.dispose();\n      this.session = null;\n    }\n\n    if (this.ws) {\n      this.ws.removeEventListener(\"open\", this.onWebsocketOpen);\n      this.ws.removeEventListener(\"close\", this.onWebsocketClose);\n      this.ws.removeEventListener(\"message\", this.onWebsocketMessage);\n      this.ws.close();\n      this.ws = null;\n    }\n  }\n\n  isDisconnected() {\n    return this.ws === null;\n  }\n\n  async onWebsocketOpen() {\n    // Create the Janus Session\n    await this.session.create();\n\n    // Attach the SFU Plugin and create a RTCPeerConnection for the publisher.\n    // The publisher sends audio and opens two bidirectional data channels.\n    // One reliable datachannel and one unreliable.\n    this.publisher = await this.createPublisher();\n\n    // Call the naf connectSuccess callback before we start receiving WebRTC messages.\n    this.connectSuccess(this.clientId);\n\n    for (let i = 0; i < this.publisher.initialOccupants.length; i++) {\n      const occupantId = this.publisher.initialOccupants[i];\n      if (occupantId === this.clientId) continue; // Happens during non-graceful reconnects due to zombie sessions\n      this.addAvailableOccupant(occupantId);\n    }\n\n    this.syncOccupants();\n  }\n\n  onWebsocketClose(event) {\n    // The connection was closed successfully. Don't try to reconnect.\n    if (event.code === WS_NORMAL_CLOSURE) {\n      return;\n    }\n\n    if (this.onReconnecting) {\n      this.onReconnecting(this.reconnectionDelay);\n    }\n\n    this.reconnectionTimeout = setTimeout(() => this.reconnect(), this.reconnectionDelay);\n  }\n\n  reconnect() {\n    // Dispose of all networked entities and other resources tied to the session.\n    this.disconnect();\n\n    this.connect()\n      .then(() => {\n        this.reconnectionDelay = this.initialReconnectionDelay;\n        this.reconnectionAttempts = 0;\n\n        if (this.onReconnected) {\n          this.onReconnected();\n        }\n      })\n      .catch(error => {\n        this.reconnectionDelay += 1000;\n        this.reconnectionAttempts++;\n\n        if (this.reconnectionAttempts > this.maxReconnectionAttempts && this.onReconnectionError) {\n          return this.onReconnectionError(\n            new Error(\"Connection could not be reestablished, exceeded maximum number of reconnection attempts.\")\n          );\n        }\n\n        console.warn(\"Error during reconnect, retrying.\");\n        console.warn(error);\n\n        if (this.onReconnecting) {\n          this.onReconnecting(this.reconnectionDelay);\n        }\n\n        this.reconnectionTimeout = setTimeout(() => this.reconnect(), this.reconnectionDelay);\n      });\n  }\n\n  performDelayedReconnect() {\n    if (this.delayedReconnectTimeout) {\n      clearTimeout(this.delayedReconnectTimeout);\n    }\n\n    this.delayedReconnectTimeout = setTimeout(() => {\n      this.delayedReconnectTimeout = null;\n      this.reconnect();\n    }, 10000);\n  }\n\n  onWebsocketMessage(event) {\n    this.session.receive(JSON.parse(event.data));\n  }\n\n  addAvailableOccupant(occupantId) {\n    if (this.availableOccupants.indexOf(occupantId) === -1) {\n      this.availableOccupants.push(occupantId);\n    }\n  }\n\n  removeAvailableOccupant(occupantId) {\n    const idx = this.availableOccupants.indexOf(occupantId);\n    if (idx !== -1) {\n      this.availableOccupants.splice(idx, 1);\n    }\n  }\n\n  syncOccupants(requestedOccupants) {\n    if (requestedOccupants) {\n      this.requestedOccupants = requestedOccupants;\n    }\n\n    if (!this.requestedOccupants) {\n      return;\n    }\n\n    // Add any requested, available, and non-pending occupants.\n    for (let i = 0; i < this.requestedOccupants.length; i++) {\n      const occupantId = this.requestedOccupants[i];\n      if (!this.occupants[occupantId] && this.availableOccupants.indexOf(occupantId) !== -1 && !this.pendingOccupants.has(occupantId)) {\n        this.addOccupant(occupantId);\n      }\n    }\n\n    // Remove any unrequested and currently added occupants.\n    for (let j = 0; j < this.availableOccupants.length; j++) {\n      const occupantId = this.availableOccupants[j];\n      if (this.occupants[occupantId] && this.requestedOccupants.indexOf(occupantId) === -1) {\n        this.removeOccupant(occupantId);\n      }\n    }\n\n    // Call the Networked AFrame callbacks for the updated occupants list.\n    this.onOccupantsChanged(this.occupants);\n  }\n\n  async addOccupant(occupantId) {\n    this.pendingOccupants.add(occupantId);\n    \n    const availableOccupantsCount = this.availableOccupants.length;\n    if (availableOccupantsCount > AVAILABLE_OCCUPANTS_THRESHOLD) {\n      await randomDelay(0, MAX_SUBSCRIBE_DELAY);\n    }\n  \n    const subscriber = await this.createSubscriber(occupantId);\n    if (subscriber) {\n      if(!this.pendingOccupants.has(occupantId)) {\n        subscriber.conn.close();\n      } else {\n        this.pendingOccupants.delete(occupantId);\n        this.occupantIds.push(occupantId);\n        this.occupants[occupantId] = subscriber;\n\n        this.setMediaStream(occupantId, subscriber.mediaStream);\n\n        // Call the Networked AFrame callbacks for the new occupant.\n        this.onOccupantConnected(occupantId);\n      }\n    }\n  }\n\n  removeAllOccupants() {\n    this.pendingOccupants.clear();\n    for (let i = this.occupantIds.length - 1; i >= 0; i--) {\n      this.removeOccupant(this.occupantIds[i]);\n    }\n  }\n\n  removeOccupant(occupantId) {\n    this.pendingOccupants.delete(occupantId);\n    \n    if (this.occupants[occupantId]) {\n      // Close the subscriber peer connection. Which also detaches the plugin handle.\n      this.occupants[occupantId].conn.close();\n      delete this.occupants[occupantId];\n      \n      this.occupantIds.splice(this.occupantIds.indexOf(occupantId), 1);\n    }\n\n    if (this.mediaStreams[occupantId]) {\n      delete this.mediaStreams[occupantId];\n    }\n\n    if (this.pendingMediaRequests.has(occupantId)) {\n      const msg = \"The user disconnected before the media stream was resolved.\";\n      this.pendingMediaRequests.get(occupantId).audio.reject(msg);\n      this.pendingMediaRequests.get(occupantId).video.reject(msg);\n      this.pendingMediaRequests.delete(occupantId);\n    }\n\n    // Call the Networked AFrame callbacks for the removed occupant.\n    this.onOccupantDisconnected(occupantId);\n  }\n\n  associate(conn, handle) {\n    conn.addEventListener(\"icecandidate\", ev => {\n      handle.sendTrickle(ev.candidate || null).catch(e => error(\"Error trickling ICE: %o\", e));\n    });\n    conn.addEventListener(\"iceconnectionstatechange\", ev => {\n      if (conn.iceConnectionState === \"failed\") {\n        console.warn(\"ICE failure detected. Reconnecting in 10s.\");\n        this.performDelayedReconnect();\n      }\n    })\n\n    // we have to debounce these because janus gets angry if you send it a new SDP before\n    // it's finished processing an existing SDP. in actuality, it seems like this is maybe\n    // too liberal and we need to wait some amount of time after an offer before sending another,\n    // but we don't currently know any good way of detecting exactly how long :(\n    conn.addEventListener(\n      \"negotiationneeded\",\n      debounce(ev => {\n        debug(\"Sending new offer for handle: %o\", handle);\n        var offer = conn.createOffer().then(this.configurePublisherSdp).then(this.fixSafariIceUFrag);\n        var local = offer.then(o => conn.setLocalDescription(o));\n        var remote = offer;\n\n        remote = remote\n          .then(this.fixSafariIceUFrag)\n          .then(j => handle.sendJsep(j))\n          .then(r => conn.setRemoteDescription(r.jsep));\n        return Promise.all([local, remote]).catch(e => error(\"Error negotiating offer: %o\", e));\n      })\n    );\n    handle.on(\n      \"event\",\n      debounce(ev => {\n        var jsep = ev.jsep;\n        if (jsep && jsep.type == \"offer\") {\n          debug(\"Accepting new offer for handle: %o\", handle);\n          var answer = conn\n            .setRemoteDescription(this.configureSubscriberSdp(jsep))\n            .then(_ => conn.createAnswer())\n            .then(this.fixSafariIceUFrag);\n          var local = answer.then(a => conn.setLocalDescription(a));\n          var remote = answer.then(j => handle.sendJsep(j));\n          return Promise.all([local, remote]).catch(e => error(\"Error negotiating answer: %o\", e));\n        } else {\n          // some other kind of event, nothing to do\n          return null;\n        }\n      })\n    );\n  }\n\n  async createPublisher() {\n    var handle = new mj.JanusPluginHandle(this.session);\n    var conn = new RTCPeerConnection(this.peerConnectionConfig || DEFAULT_PEER_CONNECTION_CONFIG);\n\n    debug(\"pub waiting for sfu\");\n    await handle.attach(\"janus.plugin.sfu\");\n\n    this.associate(conn, handle);\n\n    debug(\"pub waiting for data channels & webrtcup\");\n    var webrtcup = new Promise(resolve => handle.on(\"webrtcup\", resolve));\n\n    // Unreliable datachannel: sending and receiving component updates.\n    // Reliable datachannel: sending and recieving entity instantiations.\n    var reliableChannel = conn.createDataChannel(\"reliable\", { ordered: true });\n    var unreliableChannel = conn.createDataChannel(\"unreliable\", {\n      ordered: false,\n      maxRetransmits: 0\n    });\n\n    reliableChannel.addEventListener(\"message\", e => this.onDataChannelMessage(e, \"janus-reliable\"));\n    unreliableChannel.addEventListener(\"message\", e => this.onDataChannelMessage(e, \"janus-unreliable\"));\n\n    await webrtcup;\n    await untilDataChannelOpen(reliableChannel);\n    await untilDataChannelOpen(unreliableChannel);\n\n    // doing this here is sort of a hack around chrome renegotiation weirdness --\n    // if we do it prior to webrtcup, chrome on gear VR will sometimes put a\n    // renegotiation offer in flight while the first offer was still being\n    // processed by janus. we should find some more principled way to figure out\n    // when janus is done in the future.\n    if (this.localMediaStream) {\n      this.localMediaStream.getTracks().forEach(track => {\n        conn.addTrack(track, this.localMediaStream);\n      });\n    }\n\n    // Handle all of the join and leave events.\n    handle.on(\"event\", ev => {\n      var data = ev.plugindata.data;\n      if (data.event == \"join\" && data.room_id == this.room) {\n        this.addAvailableOccupant(data.user_id);\n        this.syncOccupants();\n      } else if (data.event == \"leave\" && data.room_id == this.room) {\n        this.removeAvailableOccupant(data.user_id);\n        this.removeOccupant(data.user_id);\n      } else if (data.event == \"blocked\") {\n        document.body.dispatchEvent(new CustomEvent(\"blocked\", { detail: { clientId: data.by } }));\n      } else if (data.event == \"unblocked\") {\n        document.body.dispatchEvent(new CustomEvent(\"unblocked\", { detail: { clientId: data.by } }));\n      } else if (data.event === \"data\") {\n        this.onData(JSON.parse(data.body), \"janus-event\");\n      }\n    });\n\n    debug(\"pub waiting for join\");\n\n    // Send join message to janus. Listen for join/leave messages. Automatically subscribe to all users' WebRTC data.\n    var message = await this.sendJoin(handle, {\n      notifications: true,\n      data: true\n    });\n\n    if (!message.plugindata.data.success) {\n      const err = message.plugindata.data.error;\n      console.error(err);\n      throw err;\n    }\n\n    var initialOccupants = message.plugindata.data.response.users[this.room] || [];\n\n    if (initialOccupants.includes(this.clientId)) {\n      console.warn(\"Janus still has previous session for this client. Reconnecting in 10s.\");\n      this.performDelayedReconnect();\n    }\n\n    debug(\"publisher ready\");\n    return {\n      handle,\n      initialOccupants,\n      reliableChannel,\n      unreliableChannel,\n      conn\n    };\n  }\n\n  configurePublisherSdp(jsep) {\n    jsep.sdp = jsep.sdp.replace(/a=fmtp:(109|111).*\\r\\n/g, (line, pt) => {\n      const parameters = Object.assign(sdpUtils.parseFmtp(line), OPUS_PARAMETERS);\n      return sdpUtils.writeFmtp({ payloadType: pt, parameters: parameters });\n    });\n    return jsep;\n  }\n\n  configureSubscriberSdp(jsep) {\n    // todo: consider cleaning up these hacks to use sdputils\n    if (!isH264VideoSupported) {\n      if (navigator.userAgent.indexOf(\"HeadlessChrome\") !== -1) {\n        // HeadlessChrome (e.g. puppeteer) doesn't support webrtc video streams, so we remove those lines from the SDP.\n        jsep.sdp = jsep.sdp.replace(/m=video[^]*m=/, \"m=\");\n      }\n    }\n\n    // TODO: Hack to get video working on Chrome for Android. https://groups.google.com/forum/#!topic/mozilla.dev.media/Ye29vuMTpo8\n    if (navigator.userAgent.indexOf(\"Android\") === -1) {\n      jsep.sdp = jsep.sdp.replace(\n        \"a=rtcp-fb:107 goog-remb\\r\\n\",\n        \"a=rtcp-fb:107 goog-remb\\r\\na=rtcp-fb:107 transport-cc\\r\\na=fmtp:107 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f\\r\\n\"\n      );\n    } else {\n      jsep.sdp = jsep.sdp.replace(\n        \"a=rtcp-fb:107 goog-remb\\r\\n\",\n        \"a=rtcp-fb:107 goog-remb\\r\\na=rtcp-fb:107 transport-cc\\r\\na=fmtp:107 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f\\r\\n\"\n      );\n    }\n    return jsep;\n  }\n\n  async fixSafariIceUFrag(jsep) {\n    // Safari produces a \\n instead of an \\r\\n for the ice-ufrag. See https://github.com/meetecho/janus-gateway/issues/1818\n    jsep.sdp = jsep.sdp.replace(/[^\\r]\\na=ice-ufrag/g, \"\\r\\na=ice-ufrag\");\n    return jsep\n  }\n\n  async createSubscriber(occupantId) {\n    if (this.availableOccupants.indexOf(occupantId) === -1) {\n      console.warn(occupantId + \": cancelled occupant connection, occupant left before subscription negotation.\");\n      return null;\n    }\n\n    var handle = new mj.JanusPluginHandle(this.session);\n    var conn = new RTCPeerConnection(this.peerConnectionConfig || DEFAULT_PEER_CONNECTION_CONFIG);\n\n    debug(occupantId + \": sub waiting for sfu\");\n    await handle.attach(\"janus.plugin.sfu\");\n\n    this.associate(conn, handle);\n\n    debug(occupantId + \": sub waiting for join\");\n\n    if (this.availableOccupants.indexOf(occupantId) === -1) {\n      conn.close();\n      console.warn(occupantId + \": cancelled occupant connection, occupant left after attach\");\n      return null;\n    }\n\n    let webrtcFailed = false;\n\n    const webrtcup = new Promise(resolve => {\n      const leftInterval = setInterval(() => {\n        if (this.availableOccupants.indexOf(occupantId) === -1) {\n          clearInterval(leftInterval);\n          resolve();\n        }\n      }, 1000);\n\n      const timeout = setTimeout(() => {\n        clearInterval(leftInterval);\n        webrtcFailed = true;\n        resolve();\n      }, SUBSCRIBE_TIMEOUT_MS);\n\n      handle.on(\"webrtcup\", () => {\n        clearTimeout(timeout);\n        clearInterval(leftInterval);\n        resolve();\n      });\n    });\n\n    // Send join message to janus. Don't listen for join/leave messages. Subscribe to the occupant's media.\n    // Janus should send us an offer for this occupant's media in response to this.\n    const resp = await this.sendJoin(handle, { media: occupantId });\n\n    if (this.availableOccupants.indexOf(occupantId) === -1) {\n      conn.close();\n      console.warn(occupantId + \": cancelled occupant connection, occupant left after join\");\n      return null;\n    }\n\n    debug(occupantId + \": sub waiting for webrtcup\");\n    await webrtcup;\n\n    if (this.availableOccupants.indexOf(occupantId) === -1) {\n      conn.close();\n      console.warn(occupantId + \": cancel occupant connection, occupant left during or after webrtcup\");\n      return null;\n    }\n\n    if (webrtcFailed) {\n      conn.close();\n      console.warn(occupantId + \": webrtc up timed out\");\n      return null;\n    }\n\n    if (isSafari && !this._iOSHackDelayedInitialPeer) {\n      // HACK: the first peer on Safari during page load can fail to work if we don't\n      // wait some time before continuing here. See: https://github.com/mozilla/hubs/pull/1692\n      await (new Promise((resolve) => setTimeout(resolve, 3000)));\n      this._iOSHackDelayedInitialPeer = true;\n    }\n\n    var mediaStream = new MediaStream();\n    var receivers = conn.getReceivers();\n    receivers.forEach(receiver => {\n      if (receiver.track) {\n        mediaStream.addTrack(receiver.track);\n      }\n    });\n    if (mediaStream.getTracks().length === 0) {\n      mediaStream = null;\n    }\n\n    debug(occupantId + \": subscriber ready\");\n    return {\n      handle,\n      mediaStream,\n      conn\n    };\n  }\n\n  sendJoin(handle, subscribe) {\n    return handle.sendMessage({\n      kind: \"join\",\n      room_id: this.room,\n      user_id: this.clientId,\n      subscribe,\n      token: this.joinToken\n    });\n  }\n\n  toggleFreeze() {\n    if (this.frozen) {\n      this.unfreeze();\n    } else {\n      this.freeze();\n    }\n  }\n\n  freeze() {\n    this.frozen = true;\n  }\n\n  unfreeze() {\n    this.frozen = false;\n    this.flushPendingUpdates();\n  }\n\n  dataForUpdateMultiMessage(networkId, message) {\n    // \"d\" is an array of entity datas, where each item in the array represents a unique entity and contains\n    // metadata for the entity, and an array of components that have been updated on the entity.\n    // This method finds the data corresponding to the given networkId.\n    for (let i = 0, l = message.data.d.length; i < l; i++) {\n      const data = message.data.d[i];\n\n      if (data.networkId === networkId) {\n        return data;\n      }\n    }\n\n    return null;\n  }\n\n  getPendingData(networkId, message) {\n    if (!message) return null;\n\n    let data = message.dataType === \"um\" ? this.dataForUpdateMultiMessage(networkId, message) : message.data;\n\n    // Ignore messages relating to users who have disconnected since freezing, their entities\n    // will have aleady been removed by NAF.\n    // Note that delete messages have no \"owner\" so we have to check for that as well.\n    if (data.owner && !this.occupants[data.owner]) return null;\n\n    // Ignore messages from users that we may have blocked while frozen.\n    if (data.owner && this.blockedClients.has(data.owner)) return null;\n\n    return data\n  }\n\n  // Used externally\n  getPendingDataForNetworkId(networkId) {\n    return this.getPendingData(networkId, this.frozenUpdates.get(networkId));\n  }\n\n  flushPendingUpdates() {\n    for (const [networkId, message] of this.frozenUpdates) {\n      let data = this.getPendingData(networkId, message);\n      if (!data) continue;\n\n      // Override the data type on \"um\" messages types, since we extract entity updates from \"um\" messages into\n      // individual frozenUpdates in storeSingleMessage.\n      const dataType = message.dataType === \"um\" ? \"u\" : message.dataType;\n\n      this.onOccupantMessage(null, dataType, data, message.source);\n    }\n    this.frozenUpdates.clear();\n  }\n\n  storeMessage(message) {\n    if (message.dataType === \"um\") { // UpdateMulti\n      for (let i = 0, l = message.data.d.length; i < l; i++) {\n        this.storeSingleMessage(message, i);\n      }\n    } else {\n      this.storeSingleMessage(message);\n    }\n  }\n\n  storeSingleMessage(message, index) {\n    const data = index !== undefined ? message.data.d[index] : message.data;\n    const dataType = message.dataType;\n    const source = message.source;\n\n    const networkId = data.networkId;\n\n    if (!this.frozenUpdates.has(networkId)) {\n      this.frozenUpdates.set(networkId, message);\n    } else {\n      const storedMessage = this.frozenUpdates.get(networkId);\n      const storedData = storedMessage.dataType === \"um\" ? this.dataForUpdateMultiMessage(networkId, storedMessage) : storedMessage.data;\n\n      // Avoid updating components if the entity data received did not come from the current owner.\n      const isOutdatedMessage = data.lastOwnerTime < storedData.lastOwnerTime;\n      const isContemporaneousMessage = data.lastOwnerTime === storedData.lastOwnerTime;\n      if (isOutdatedMessage || (isContemporaneousMessage && storedData.owner > data.owner)) {\n        return;\n      }\n\n      if (dataType === \"r\") {\n        const createdWhileFrozen = storedData && storedData.isFirstSync;\n        if (createdWhileFrozen) {\n          // If the entity was created and deleted while frozen, don't bother conveying anything to the consumer.\n          this.frozenUpdates.delete(networkId);\n        } else {\n          // Delete messages override any other messages for this entity\n          this.frozenUpdates.set(networkId, message);\n        }\n      } else {\n        // merge in component updates\n        if (storedData.components && data.components) {\n          Object.assign(storedData.components, data.components);\n        }\n      }\n    }\n  }\n\n  onDataChannelMessage(e, source) {\n    this.onData(JSON.parse(e.data), source);\n  }\n\n  onData(message, source) {\n    if (debug.enabled) {\n      debug(`DC in: ${message}`);\n    }\n\n    if (!message.dataType) return;\n\n    message.source = source;\n\n    if (this.frozen) {\n      this.storeMessage(message);\n    } else {\n      this.onOccupantMessage(null, message.dataType, message.data, message.source);\n    }\n  }\n\n  shouldStartConnectionTo(client) {\n    return true;\n  }\n\n  startStreamConnection(client) {}\n\n  closeStreamConnection(client) {}\n\n  getConnectStatus(clientId) {\n    return this.occupants[clientId] ? NAF.adapters.IS_CONNECTED : NAF.adapters.NOT_CONNECTED;\n  }\n\n  async updateTimeOffset() {\n    if (this.isDisconnected()) return;\n\n    const clientSentTime = Date.now();\n\n    const res = await fetch(document.location.href, {\n      method: \"HEAD\",\n      cache: \"no-cache\"\n    });\n\n    const precision = 1000;\n    const serverReceivedTime = new Date(res.headers.get(\"Date\")).getTime() + precision / 2;\n    const clientReceivedTime = Date.now();\n    const serverTime = serverReceivedTime + (clientReceivedTime - clientSentTime) / 2;\n    const timeOffset = serverTime - clientReceivedTime;\n\n    this.serverTimeRequests++;\n\n    if (this.serverTimeRequests <= 10) {\n      this.timeOffsets.push(timeOffset);\n    } else {\n      this.timeOffsets[this.serverTimeRequests % 10] = timeOffset;\n    }\n\n    this.avgTimeOffset = this.timeOffsets.reduce((acc, offset) => (acc += offset), 0) / this.timeOffsets.length;\n\n    if (this.serverTimeRequests > 10) {\n      debug(`new server time offset: ${this.avgTimeOffset}ms`);\n      setTimeout(() => this.updateTimeOffset(), 5 * 60 * 1000); // Sync clock every 5 minutes.\n    } else {\n      this.updateTimeOffset();\n    }\n  }\n\n  getServerTime() {\n    return Date.now() + this.avgTimeOffset;\n  }\n\n  getMediaStream(clientId, type = \"audio\") {\n    if (this.mediaStreams[clientId]) {\n      debug(`Already had ${type} for ${clientId}`);\n      return Promise.resolve(this.mediaStreams[clientId][type]);\n    } else {\n      debug(`Waiting on ${type} for ${clientId}`);\n      if (!this.pendingMediaRequests.has(clientId)) {\n        this.pendingMediaRequests.set(clientId, {});\n\n        const audioPromise = new Promise((resolve, reject) => {\n          this.pendingMediaRequests.get(clientId).audio = { resolve, reject };\n        });\n        const videoPromise = new Promise((resolve, reject) => {\n          this.pendingMediaRequests.get(clientId).video = { resolve, reject };\n        });\n\n        this.pendingMediaRequests.get(clientId).audio.promise = audioPromise;\n        this.pendingMediaRequests.get(clientId).video.promise = videoPromise;\n\n        audioPromise.catch(e => console.warn(`${clientId} getMediaStream Audio Error`, e));\n        videoPromise.catch(e => console.warn(`${clientId} getMediaStream Video Error`, e));\n      }\n      return this.pendingMediaRequests.get(clientId)[type].promise;\n    }\n  }\n\n  setMediaStream(clientId, stream) {\n    // Safari doesn't like it when you use single a mixed media stream where one of the tracks is inactive, so we\n    // split the tracks into two streams.\n    const audioStream = new MediaStream();\n    try {\n    stream.getAudioTracks().forEach(track => audioStream.addTrack(track));\n\n    } catch(e) {\n      console.warn(`${clientId} setMediaStream Audio Error`, e);\n    }\n    const videoStream = new MediaStream();\n    try {\n    stream.getVideoTracks().forEach(track => videoStream.addTrack(track));\n\n    } catch (e) {\n      console.warn(`${clientId} setMediaStream Video Error`, e);\n    }\n\n    this.mediaStreams[clientId] = { audio: audioStream, video: videoStream };\n\n    // Resolve the promise for the user's media stream if it exists.\n    if (this.pendingMediaRequests.has(clientId)) {\n      this.pendingMediaRequests.get(clientId).audio.resolve(audioStream);\n      this.pendingMediaRequests.get(clientId).video.resolve(videoStream);\n    }\n  }\n\n  async setLocalMediaStream(stream) {\n    // our job here is to make sure the connection winds up with RTP senders sending the stuff in this stream,\n    // and not the stuff that isn't in this stream. strategy is to replace existing tracks if we can, add tracks\n    // that we can't replace, and disable tracks that don't exist anymore.\n\n    // note that we don't ever remove a track from the stream -- since Janus doesn't support Unified Plan, we absolutely\n    // can't wind up with a SDP that has >1 audio or >1 video tracks, even if one of them is inactive (what you get if\n    // you remove a track from an existing stream.)\n    if (this.publisher && this.publisher.conn) {\n      const existingSenders = this.publisher.conn.getSenders();\n      const newSenders = [];\n      const tracks = stream.getTracks();\n\n      for (let i = 0; i < tracks.length; i++) {\n        const t = tracks[i];\n        const sender = existingSenders.find(s => s.track != null && s.track.kind == t.kind);\n\n        if (sender != null) {\n          if (sender.replaceTrack) {\n            await sender.replaceTrack(t);\n\n            // Workaround https://bugzilla.mozilla.org/show_bug.cgi?id=1576771\n            if (t.kind === \"video\" && t.enabled && navigator.userAgent.toLowerCase().indexOf('firefox') > -1) {\n              t.enabled = false;\n              setTimeout(() => t.enabled = true, 1000);\n            }\n          } else {\n            // Fallback for browsers that don't support replaceTrack. At this time of this writing\n            // most browsers support it, and testing this code path seems to not work properly\n            // in Chrome anymore.\n            stream.removeTrack(sender.track);\n            stream.addTrack(t);\n          }\n          newSenders.push(sender);\n        } else {\n          newSenders.push(this.publisher.conn.addTrack(t, stream));\n        }\n      }\n      existingSenders.forEach(s => {\n        if (!newSenders.includes(s)) {\n          s.track.enabled = false;\n        }\n      });\n    }\n    this.localMediaStream = stream;\n    this.setMediaStream(this.clientId, stream);\n  }\n\n  enableMicrophone(enabled) {\n    if (this.publisher && this.publisher.conn) {\n      this.publisher.conn.getSenders().forEach(s => {\n        if (s.track.kind == \"audio\") {\n          s.track.enabled = enabled;\n        }\n      });\n    }\n  }\n\n  sendData(clientId, dataType, data) {\n    if (!this.publisher) {\n      console.warn(\"sendData called without a publisher\");\n    } else {\n      switch (this.unreliableTransport) {\n        case \"websocket\":\n          this.publisher.handle.sendMessage({ kind: \"data\", body: JSON.stringify({ dataType, data }), whom: clientId });\n          break;\n        case \"datachannel\":\n          this.publisher.unreliableChannel.send(JSON.stringify({ clientId, dataType, data }));\n          break;\n        default:\n          this.unreliableTransport(clientId, dataType, data);\n          break;\n      }\n    }\n  }\n\n  sendDataGuaranteed(clientId, dataType, data) {\n    if (!this.publisher) {\n      console.warn(\"sendDataGuaranteed called without a publisher\");\n    } else {\n      switch (this.reliableTransport) {\n        case \"websocket\":\n          this.publisher.handle.sendMessage({ kind: \"data\", body: JSON.stringify({ dataType, data }), whom: clientId });\n          break;\n        case \"datachannel\":\n          this.publisher.reliableChannel.send(JSON.stringify({ clientId, dataType, data }));\n          break;\n        default:\n          this.reliableTransport(clientId, dataType, data);\n          break;\n      }\n    }\n  }\n\n  broadcastData(dataType, data) {\n    if (!this.publisher) {\n      console.warn(\"broadcastData called without a publisher\");\n    } else {\n      switch (this.unreliableTransport) {\n        case \"websocket\":\n          this.publisher.handle.sendMessage({ kind: \"data\", body: JSON.stringify({ dataType, data }) });\n          break;\n        case \"datachannel\":\n          this.publisher.unreliableChannel.send(JSON.stringify({ dataType, data }));\n          break;\n        default:\n          this.unreliableTransport(undefined, dataType, data);\n          break;\n      }\n    }\n  }\n\n  broadcastDataGuaranteed(dataType, data) {\n    if (!this.publisher) {\n      console.warn(\"broadcastDataGuaranteed called without a publisher\");\n    } else {\n      switch (this.reliableTransport) {\n        case \"websocket\":\n          this.publisher.handle.sendMessage({ kind: \"data\", body: JSON.stringify({ dataType, data }) });\n          break;\n        case \"datachannel\":\n          this.publisher.reliableChannel.send(JSON.stringify({ dataType, data }));\n          break;\n        default:\n          this.reliableTransport(undefined, dataType, data);\n          break;\n      }\n    }\n  }\n\n  kick(clientId, permsToken) {\n    return this.publisher.handle.sendMessage({ kind: \"kick\", room_id: this.room, user_id: clientId, token: permsToken }).then(() => {\n      document.body.dispatchEvent(new CustomEvent(\"kicked\", { detail: { clientId: clientId } }));\n    });\n  }\n\n  block(clientId) {\n    return this.publisher.handle.sendMessage({ kind: \"block\", whom: clientId }).then(() => {\n      this.blockedClients.set(clientId, true);\n      document.body.dispatchEvent(new CustomEvent(\"blocked\", { detail: { clientId: clientId } }));\n    });\n  }\n\n  unblock(clientId) {\n    return this.publisher.handle.sendMessage({ kind: \"unblock\", whom: clientId }).then(() => {\n      this.blockedClients.delete(clientId);\n      document.body.dispatchEvent(new CustomEvent(\"unblocked\", { detail: { clientId: clientId } }));\n    });\n  }\n}\n\nNAF.adapters.register(\"janus\", JanusAdapter);\n\nmodule.exports = JanusAdapter;\n"],"sourceRoot":""}
diff --git a/media/assets/webui/apps/comms/external/naf-shim.js b/media/assets/webui/apps/comms/external/naf-shim.js
new file mode 100644
index 0000000000000000000000000000000000000000..160608804392bdcb585046551743c3bf00f937fe
--- /dev/null
+++ b/media/assets/webui/apps/comms/external/naf-shim.js
@@ -0,0 +1,152 @@
+window.NAF = {
+  adapters: {
+    adapters: {},
+    register: function(name, instance) {
+      console.log('NAF registered adapter', name, instance);
+      NAF.adapters.adapters[name] = instance;
+    },
+    make: function(name) {
+      return new NAF.adapters.adapters[name];
+    }
+  }
+};
+class JanusNAF extends EventTarget {
+  constructor(clientId) {
+    super();
+    this.clientId = clientId;
+    this.connectedClients = {};
+    this.activeDataChannels = {};
+  }
+  connect(serverURL, appName, roomName) {
+    let adapter = NAF.adapters.make('janus');
+    adapter.setServerUrl(serverURL);
+    adapter.setApp(appName);
+    adapter.setRoom(roomName);
+    adapter.setClientId(this.clientId);
+    adapter.setPeerConnectionConfig(this.getPeerConnectionConfig());
+    console.log('I have an adapter', adapter, this.clientId);
+
+    var webrtcOptions = this.getMediaConstraints();
+    adapter.setWebRtcOptions(webrtcOptions);
+
+    adapter.setServerConnectListeners(
+      this.connectSuccess.bind(this),
+      this.connectFailure.bind(this)
+    );
+    adapter.setDataChannelListeners(
+      this.dataChannelOpen.bind(this),
+      this.dataChannelClosed.bind(this),
+      this.receivedData.bind(this)
+    );
+    adapter.setRoomOccupantListener(this.occupantsReceived.bind(this));
+
+    this.adapter = adapter;
+    return this.adapter.connect();
+  }
+  getMediaConstraints() {
+    return {
+      audio: {
+        echoCancellation: false,
+        autoGainControl: false,
+        noiseSuppression: false,
+      },
+      video: {
+        width: 256,
+        height: 256,
+      },
+/*
+      audio: true,
+      video: true,
+*/
+      datachannel: true
+    };
+  }
+  connectSuccess(clientId) {
+    console.log('connected', clientId);
+    //adapter.clientId = clientId;
+    this.adapter.session.verbose = true;
+
+
+/*
+    navigator.mediaDevices.getUserMedia(this.getMediaConstraints())
+      .then(localStream => {
+        console.log('got mic', localStream);
+        this.adapter.setLocalMediaStream(localStream);
+        this.dispatchEvent(new CustomEvent('voip-media-change', {detail: { stream: localStream }}));
+      });
+*/
+
+
+  }
+  connectFailure(id) {
+console.log('connect failed', id);
+  }
+  dataChannelOpen(id) {
+console.log('datachannel open', id);
+    let ms = this.adapter.mediaStreams[id];
+    if (ms) {
+      this.dispatchEvent(new CustomEvent('voip-user-connect', {detail: { id: id, media: ms }}));
+    }
+  }
+  dataChannelClosed(id) {
+console.log('datachannel closed', id);
+    this.dispatchEvent(new CustomEvent('voip-user-disconnect', {detail: { id: id }}));
+  }
+  receivedData(id) {
+console.log('received data', id);
+  }
+  occupantsReceived(occupantList) {
+console.log('occupants received', occupantList);
+    var prevConnectedClients = Object.assign({}, this.connectedClients);
+    this.connectedClients = occupantList;
+    this.checkForDisconnectingClients(prevConnectedClients, occupantList);
+    this.checkForConnectingClients(occupantList);
+  }
+
+  checkForDisconnectingClients(oldOccupantList, newOccupantList) {
+    for (var id in oldOccupantList) {
+      var clientFound = newOccupantList[id];
+      if (!clientFound) {
+        NAF.log.write('Closing stream to ', id);
+        this.adapter.closeStreamConnection(id);
+      }
+    }
+  }
+
+  isNewClient(id) {
+    return !(id in this.adapter.occupants);
+  }
+  // Some adapters will handle this internally
+  checkForConnectingClients(occupantList) {
+    for (var id in occupantList) {
+      var startConnection = this.isNewClient(id) && this.adapter.shouldStartConnectionTo(occupantList[id]);
+      if (startConnection) {
+        //NAF.log.write('Opening datachannel to ', id);
+        this.adapter.startStreamConnection(id);
+      }
+    }
+  }
+
+  getConnectedClients() {
+    return this.connectedClients;
+  }
+  getPeerConnectionConfig() {
+    return {
+      'iceServers': [
+        {
+          'urls': [
+            'stun:stun.l.google.com:19302',
+          ]
+        },
+        {
+          'username': 'turn',
+          'credential': 'turn',
+          'realm': 'turn',
+          'urls': [
+            'turns:voip.janusxr.org:3478',
+          ]
+        },
+      ]
+    };
+  }
+}
diff --git a/media/assets/webui/apps/comms/voip.css b/media/assets/webui/apps/comms/voip.css
new file mode 100644
index 0000000000000000000000000000000000000000..d0c7feb102047f34cbd7e6a4bfe96af3c30e228d
--- /dev/null
+++ b/media/assets/webui/apps/comms/voip.css
@@ -0,0 +1,76 @@
+janus-voip-client {
+  display: block;
+  border: 1px solid black;
+  position: relative;
+}
+janus-voip-localuser {
+  display: block;
+  position: absolute;
+  bottom: 0px;
+  right: -72px; 
+  border: 1px solid black;
+  padding: 0px;
+  background: white;
+  box-shadow: 0 0 5px black;
+  z-index: 10;
+}
+janus-voip-localuser video {
+  max-width: 64px;
+  height: 64px;
+  display: block;
+  margin: 1px 0 0 1px;
+}
+janus-voip-remoteuser {
+  display: inline-block;
+  border: 1px solid black;
+  position: relative;
+  font-family: monospace;
+  transition: transform 250ms ease;
+  transform: scale(0, 0);
+  min-width: 5em;
+}
+janus-voip-remoteuser video {
+  display: none;
+  max-width: 128px;
+  height: 128px;
+}
+janus-voip-remoteuser video.active {
+  display: block;
+}
+janus-voip-remoteuser[active] {
+  transform: scale(1, 1);
+}
+janus-voip-remoteuser h2 {
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  margin: 0;
+  background: rgba(0,0,0,.2);
+  text-shadow: 0 0 5px black;
+  color: white;
+  font-size: .8em;
+}
+janus-voip-remoteuser {
+}
+janus-voip-localuser ui-button {
+}
+janus-voip-localuser ui-button.muted {
+  background: red;
+}
+janus-voip-picker-audio {
+  display: block;
+  text-align: center;
+}
+janus-voip-picker-audio ul {
+  list-style: none;
+  text-align: left;
+  width: 20em;
+  margin: 0 auto;
+}
+janus-voip-picker-audio ui-label {
+  width: 10em;
+}
+janus-voip-picker-audio ui-select>select {
+  width: 100%;
+}
diff --git a/media/assets/webui/apps/comms/voip.js b/media/assets/webui/apps/comms/voip.js
new file mode 100644
index 0000000000000000000000000000000000000000..626736498ac8903b2c0bd769468e691fa8805d50
--- /dev/null
+++ b/media/assets/webui/apps/comms/voip.js
@@ -0,0 +1,440 @@
+elation.elements.define('janus-voip-client', class extends elation.elements.base {
+  create() {
+    this.connect();
+  }
+  connect() {
+    let sfu = new JanusNAF(player.getNetworkUsername()); //'testclient-' + Math.floor(Math.random() * 1e6));
+
+console.log('new thing', room.id);
+    sfu.connect('wss://voip.janusxr.org/', 'default', room.id, true);
+
+    this.localuser = document.createElement('janus-voip-localuser');
+    this.appendChild(this.localuser);
+
+    let remoteusers = {};
+    sfu.addEventListener('voip-media-change', (ev) => {
+      console.log('got some media', ev.detail);
+      this.localuser.setData(ev.detail.stream);
+    });
+    sfu.addEventListener('voip-user-connect', (ev) => {
+      console.log('new client', ev);
+      let el = document.createElement('janus-voip-remoteuser');
+      el.setUserData(ev.detail);
+      this.appendChild(el);
+      remoteusers[ev.detail.id] = el;
+    });
+    sfu.addEventListener('voip-user-disconnect', (ev) => {
+      let userid = ev.detail.id,
+          user = remoteusers[userid];
+      if (user) {
+        user.destroy();
+setTimeout(() => this.removeChild(user), 250);
+      }
+    });
+    document.addEventListener('voip-picker-select', ev => {
+      let localStream = ev.detail;
+      sfu.adapter.setLocalMediaStream(localStream);
+      sfu.dispatchEvent(new CustomEvent('voip-media-change', {detail: { stream: localStream }}));
+    });
+  }
+});
+
+elation.elements.define('janus-voip-localuser', class extends elation.elements.base {
+  setData(data) {
+console.log('set my local data', data);
+    this.muted = false;
+
+    if (this.video) {
+      this.removeChild(this.video);
+    }
+
+    // video
+    let video = document.createElement('video');
+    video.srcObject = data;
+    this.appendChild(video);
+    video.muted = true;
+    video.play();
+    this.video = video;
+
+    if (!this.mutebutton) {
+      let mute = elation.elements.create('ui-button', {label: 'Mute'});
+      this.appendChild(mute);
+      mute.addEventListener('click', (ev) => this.toggleMute());
+      this.mutebutton = mute;
+    }
+    // audio
+/*
+    let audio = document.createElement('audio');
+    audio.srcObject = data.media.audio;
+    this.appendChild(video);
+    audio.play();
+    this.audio = audio;
+*/
+    this.stream = data;
+
+/*
+    player.createObject('object', {
+      id: 'cone',
+      col: '#4cb96f',
+      scale: V(.2),
+      pos: V(0, 1.8, 0),
+      autosync: true
+    });
+*/
+  }
+  toggleMute() {
+    this.muted = !this.muted;
+    this.stream.getAudioTracks().forEach(track => track.enabled = !this.muted);
+    if (this.muted) {
+      this.mutebutton.addclass('muted');
+    } else {
+      this.mutebutton.removeclass('muted');
+    }
+  }
+  
+});
+elation.elements.define('janus-voip-remoteuser', class extends elation.elements.base {
+  create() {
+    setTimeout(() => this.setAttribute('active', true), 100);
+  }
+  setUserData(data) {
+    this.id = data.id;
+
+    let label = document.createElement('h2');
+    label.innerText = this.id;
+    this.appendChild(label);
+    this.label = label;
+
+    if (data.media.video) {
+      let track = data.media.video.getVideoTracks()[0];
+      data.media.video.addEventListener('addtrack', (ev) => console.log('a track was added', ev));
+      data.media.video.addEventListener('removetrack', (ev) => console.log('a track was added', ev));
+      let video = document.createElement('video');
+      video.muted = true;
+      video.srcObject = data.media.video;
+      this.appendChild(video);
+      video.play();
+      this.video = video;
+      video.addEventListener('resize', (ev) => { console.log('video resized', video); this.updateVideo(); });
+      this.updateVideo();
+    }
+
+    // audio
+    let audio = document.createElement('audio');
+    audio.srcObject = data.media.audio;
+    this.audio = audio;
+
+    let remoteuser = janus.network.remoteplayers[this.id];
+    if (remoteuser) {
+      remoteuser.addVoice(data.media.audio);
+      this.audio.muted = true;
+
+      // FIXME - this is pretty unreliable right now, probably some race conditions about loading the avatar vs when we get the video stream
+      //         it also breaks if the avatar changes their avatar after initializing their webcam
+/*
+      setTimeout(() => {
+        let screenid = 'screen_Cube.004';
+        if (this.video) {
+          let face = remoteuser.face;
+  console.log('video guy has a face', face, this.video);
+          if (face && face.parts) {
+            let screen = this.screen;
+            if (face !== this.face) {
+              this.face = remoteuser.face;
+              screen = false;
+            }
+            if (!screen) {
+              screen = face.parts[screenid];
+            }
+  console.log('face has a screen', screen);
+            if (screen) {
+              let videoid = this.id + '_video';
+              room.loadNewAsset('video', { id: videoid, video: this.video });
+              screen.video_id = videoid;
+              screen.lighting = false;
+            }
+          }
+        }
+      }, 2000);
+*/
+      if (this.video) {
+        remoteuser.setRemoteVideo(this.video);
+      }
+    }
+
+    console.log('got remote media', data, remoteuser);
+  }
+  destroy() {
+    console.log('stop media', this.id);
+    if (this.video) {
+      //this.video.stop();
+    }
+    if (this.audio) {
+      //this.audio.stop();
+    }
+    this.removeAttribute('active');
+  }
+  updateVideo() {
+    let video = this.video;
+    if (video) {
+      let hasclass = elation.html.hasclass(video, 'active');
+      if (video.videoWidth > 0 && video.videoHeight > 0 && !hasclass) {
+        elation.html.addclass(video, 'active');
+      } else if (hasclass && (video.videoWidth == 0 || video.videoHeight == 0)) {
+        elation.html.removeclass(video, 'active');
+      }
+    }
+  }
+});
+elation.elements.define('janus-voip-picker', class extends elation.elements.base {
+  create() {
+    this.elements = elation.elements.fromString(`
+       

+         
Just observing
+         
With my microphone
+         
+       
+    `, this);
+
+    this.elements.none.addEventListener('click', (ev) => this.handleSelectNone());
+    this.elements.audio.addEventListener('click', (ev) => this.handleSelectAudio(ev));
+    //this.elements.video.addEventListener('click', (ev) => this.handleSelectVideo());
+  }
+  handleSelectNone() {
+    console.log('selected none');
+    janus.engine.systems.sound.enableSound();
+    this.dispatchEvent(new CustomEvent('select', { detail: false }));
+  }
+  handleSelectAudio(ev) {
+    console.log('selected audio', ev.detail);
+    janus.engine.systems.sound.enableSound();
+    if (!this.subpicker) {
+      this.subpicker = elation.elements.create('janus-voip-picker-audio');
+      this.appendChild(this.subpicker);
+      elation.events.add(this.subpicker, 'select', ev => {
+        document.dispatchEvent(new CustomEvent('voip-picker-select', { detail: ev.detail }));
+        this.dispatchEvent(new CustomEvent('select', { detail: ev.detail }));
+      });
+    }
+  }
+  handleSelectVideo() {
+    console.log('selected video');
+    this.dispatchEvent(new CustomEvent('select', { detail: 'video' }));
+  }
+});
+elation.elements.define('janus-voip-picker-audio', class extends elation.elements.base {
+  create() {
+    this.elements = elation.elements.fromString(`
+      

+        
+        Waiting for permission to be granted
+      
+      
+      
Microphone
+      

+        

+        
+        

+        

+      
+      
Video Input
+      

+        

+        

+      
+      Continue
+    `, this);
+
+    janus.engine.systems.sound.enableSound();
+    this.getUserMedia();
+
+    this.elements.inputDevice.addEventListener('change', (ev) => this.getUserMedia());
+    this.elements.videoDevice.addEventListener('change', (ev) => this.getUserMedia());
+    //this.elements.outputDevice.addEventListener('change', (ev) => this.getUserMedia());
+    elation.events.add(this.elements.echoCancellation, 'toggle', (ev) => this.getUserMedia());
+    elation.events.add(this.elements.noiseSuppression, 'toggle', (ev) => this.getUserMedia());
+    //elation.events.add(this.elements.webcam, 'toggle', (ev) => this.getUserMedia());
+    elation.events.add(this.elements.submit, 'click', (ev) => { 
+      this.dispatchEvent(new CustomEvent('select', {detail: this.stream})); 
+    });
+    elation.events.add(this.elements.webcamEnabled, 'toggle', (ev) => {
+      console.log('toggled', ev.data, ev);
+      if (ev.data) {
+        this.getUserMedia({video: true});
+      }
+    });
+  }
+  updateDevices() {
+    navigator.mediaDevices.enumerateDevices()
+      .then(devices => {
+        this.devices = devices;
+        let inputs = this.elements.inputDevice,
+            cameras = this.elements.videoDevice,
+            outputs = this.elements.outputDevice;
+
+        // FIXME - I'm not really using these UI elements properly here, I shouldn't be mucking with the HTML elements directly
+        inputs.select.innerHTML = '';
+        cameras.select.innerHTML = '';
+        //outputs.select.innerHTML = '';
+
+        let hasWebcamPermission = true;
+        let webcamDisabled = elation.elements.create('option', {innerHTML: 'Disabled', value: 'none', append: cameras.select});
+        devices.forEach(d => {
+          if (d.kind == 'audioinput') {
+            elation.elements.create('option', {innerHTML: d.label, value: d.deviceId, append: inputs.select});
+          } else if (cameras && d.kind == 'videoinput') {
+console.log('got a videoinput', d);
+            if (d.deviceId == '') {
+              hasWebcamPermission = false;
+            } else {
+              elation.elements.create('option', {innerHTML: d.label, value: d.deviceId, append: cameras.select});
+            }
+          } else if (outputs && d.kind == 'audiooutput') {
+            elation.elements.create('option', {innerHTML: d.label, value: d.deviceId, append: outputs.select});
+          }
+        });        
+        if (hasWebcamPermission) {
+          this.elements.webcamEnabled.hide();
+          this.elements.videoDevice.show();
+        } else {
+          console.log('NO WEBCAM PERMISSION');
+          this.elements.webcamEnabled.show();
+          this.elements.videoDevice.hide();
+        }
+      });
+
+  }
+
+  getUserMediaConstraints(args={}) {
+    let constraints = {
+      audio: args.audio || {},
+      video: args.video || false,
+    };
+    constraints.audio.echoCancellation = { exact: this.elements.echoCancellation.checked };
+    constraints.audio.noiseSuppression = { exact: this.elements.noiseSuppression.checked };
+    constraints.audio.autoGainControl = { exact: false };
+
+    if (this.elements.inputDevice.value && this.elements.inputDevice.value != 'default') {
+      console.log('input!', this.elements.inputDevice.value);
+      constraints.audio.deviceId = { exact: this.elements.inputDevice.value };
+    }
+    if (this.elements.videoDevice.value && this.elements.videoDevice.value != 'none') {
+      console.log('video!', this.elements.videoDevice.value);
+      constraints.video = {
+        deviceId: { exact: this.elements.videoDevice.value },
+        height: 256,
+        width: 256
+      };
+    }
+
+    return constraints;
+  }
+  getUserMedia(overrideconstraints) {
+
+    let constraints = this.getUserMediaConstraints(overrideconstraints);
+    navigator.mediaDevices.getUserMedia(constraints)
+      .then(stream => {
+        this.elements.mictest.setStream(stream);
+        if (this.stream) {
+          let tracks = this.stream.getTracks();
+          tracks.forEach(t => {
+            t.stop();
+          });
+        }
+        this.stream = stream;
+
+        if (!this.devices || overrideconstraints) {
+          this.updateDevices();
+        }
+      });
+  }
+});
+elation.elements.define('janus-voip-picker-mictest', class extends elation.elements.base {
+  create() {
+    let canvas = document.createElement('canvas');
+    canvas.width = 150;
+    canvas.height = 50;
+    this.canvas = canvas;
+    this.appendChild(canvas);
+  }
+  setStream(stream) {
+    let listener = player.engine.systems.sound.getRealListener();
+    let context = listener.context;
+    console.log('my mic stream', stream, context);
+    let source = context.createMediaStreamSource(stream);
+    let analyser = context.createAnalyser();
+    source.connect(analyser);
+
+    this.stream = stream;
+    this.analyser = analyser;
+
+    analyser.fftSize = 256;
+    var bufferLength = analyser.frequencyBinCount;
+    this.dataArray = new Uint8Array(bufferLength);
+
+    this.drawFrequencies();
+  }
+  drawWaveform() {
+    let canvas = this.canvas,
+        ctx = canvas.getContext('2d'),
+        bufferLength = this.dataArray.length;
+    this.analyser.getByteTimeDomainData(this.dataArray);
+
+    //ctx.fillStyle = 'rgb(0, 0, 0)';
+    //ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+
+    ctx.lineWidth = 2;
+    ctx.strokeStyle = 'rgb(0,255,0, .6)';
+    ctx.beginPath();
+
+
+    let slicewidth = this.canvas.width / bufferLength;
+    for (let i = 0, x = 0; i < bufferLength; i++) {
+      let y = this.canvas.height / 2 + 1.5 * (this.dataArray[i] - 128);
+      if (i == 0) {
+        ctx.moveTo(x, y);
+      } else {
+        ctx.lineTo(x, y);
+      }
+      x += slicewidth;
+    }
+
+    ctx.lineTo(this.canvas.width, this.canvas.height/2);
+    ctx.stroke();
+
+    //requestAnimationFrame(() => this.drawWaveform());
+  }
+  drawFrequencies() {
+    let canvas = this.canvas,
+        ctx = canvas.getContext('2d'),
+        dataArray = this.dataArray,
+        bufferLength = dataArray.length,
+        analyser = this.analyser;;
+
+    analyser.getByteFrequencyData(this.dataArray);
+
+    ctx.fillStyle = "#000";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+
+    let barWidth = (canvas.width / bufferLength) * 2.5,
+        x = 0;
+
+    for (var i = 0; i < bufferLength; i++) {
+      let barHeight = dataArray[i];
+      
+      var g = 255; //barHeight + (25 * (i/bufferLength));
+      //var r = 250 * (i/bufferLength);
+      var r = barHeight + (25 * (i/bufferLength));
+      var b = 50;
+
+      //ctx.fillStyle = "rgb(" + r + "," + g + "," + b + ")";
+      ctx.fillStyle = '#4cb96f';
+      ctx.fillRect(x, (canvas.height - barHeight) / 2, barWidth, barHeight);
+
+      x += barWidth + 1;
+    }
+    this.drawWaveform();
+
+    requestAnimationFrame(() => this.drawFrequencies());
+  }
+});
diff --git a/scripts/remoteplayer.js b/scripts/remoteplayer.js

--- a/scripts/remoteplayer.js
+++ b/scripts/remoteplayer.js
@@ -58,6 +58,7 @@ elation.component.add('engine.things.remoteplayer', function() {
       collidable: false
     });
 */
+/*
     this.label = this.createObject('text', {
       size: .1,
       thickness: .002,
@@ -70,6 +71,7 @@ elation.component.add('engine.things.remoteplayer', function() {
       collidable: false,
       billboard: 'y'
     });
+*/
     if (this.engine.client.player.usevoip && this.engine.systems.sound.canPlaySound) {
       this.mouth = this.head.spawn('sound', this.properties.player_name + '_voice', {
         //loop: true

-----END OF PAGE-----