podchat-browser 11.3.2 → 11.4.1

package/dist/{podchat-11.2.1.js → podchat-11.3.4.js}

@@ -26736,7 +26736,7 @@ function config (name) {
 },{}],188:[function(require,module,exports){
 window.PodChat = require('./src/chat.js');
 
-},{"./src/chat.js":330}],189:[function(require,module,exports){
+},{"./src/chat.js":331}],189:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var core_1 = require("@sentry/core");
@@ -26787,7 +26787,7 @@ var BrowserBackend = /** @class */ (function (_super) {
 }(core_1.BaseBackend));
 exports.BrowserBackend = BrowserBackend;
 
-},{"./eventbuilder":191,"./transports":207,"@sentry/core":213,"@sentry/types":228,"@sentry/utils":238,"tslib":312}],190:[function(require,module,exports){
+},{"./eventbuilder":191,"./transports":207,"@sentry/core":213,"@sentry/types":228,"@sentry/utils":238,"tslib":313}],190:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var core_1 = require("@sentry/core");
@@ -26864,7 +26864,7 @@ var BrowserClient = /** @class */ (function (_super) {
 }(core_1.BaseClient));
 exports.BrowserClient = BrowserClient;
 
-},{"./backend":189,"./helpers":193,"./integrations":198,"@sentry/core":213,"@sentry/utils":238,"tslib":312}],191:[function(require,module,exports){
+},{"./backend":189,"./helpers":193,"./integrations":198,"@sentry/core":213,"@sentry/utils":238,"tslib":313}],191:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var types_1 = require("@sentry/types");
@@ -26989,7 +26989,7 @@ function eventFromString(input, syntheticException, options) {
 }
 exports.eventFromString = eventFromString;
 
-},{"./parsers":202,"./tracekit":204,"@sentry/types":228,"@sentry/utils":238,"tslib":312}],192:[function(require,module,exports){
+},{"./parsers":202,"./tracekit":204,"@sentry/types":228,"@sentry/utils":238,"tslib":313}],192:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var types_1 = require("@sentry/types");
 exports.Severity = types_1.Severity;
@@ -27199,7 +27199,7 @@ function injectReportDialog(options) {
 }
 exports.injectReportDialog = injectReportDialog;
 
-},{"@sentry/core":213,"@sentry/utils":238,"tslib":312}],194:[function(require,module,exports){
+},{"@sentry/core":213,"@sentry/utils":238,"tslib":313}],194:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./exports"), exports);
@@ -27217,7 +27217,7 @@ if (_window.Sentry && _window.Sentry.Integrations) {
 var INTEGRATIONS = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, windowIntegrations), core_1.Integrations), BrowserIntegrations);
 exports.Integrations = INTEGRATIONS;
 
-},{"./exports":192,"./integrations":198,"./transports":207,"@sentry/core":213,"@sentry/utils":238,"tslib":312}],195:[function(require,module,exports){
+},{"./exports":192,"./integrations":198,"./transports":207,"@sentry/core":213,"@sentry/utils":238,"tslib":313}],195:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
@@ -27487,7 +27487,7 @@ var Breadcrumbs = /** @class */ (function () {
 }());
 exports.Breadcrumbs = Breadcrumbs;
 
-},{"@sentry/core":213,"@sentry/types":228,"@sentry/utils":238,"tslib":312}],196:[function(require,module,exports){
+},{"@sentry/core":213,"@sentry/types":228,"@sentry/utils":238,"tslib":313}],196:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 /** Deduplication filter */
 var Dedupe = /** @class */ (function () {
@@ -27857,7 +27857,7 @@ var GlobalHandlers = /** @class */ (function () {
 }());
 exports.GlobalHandlers = GlobalHandlers;
 
-},{"../eventbuilder":191,"../helpers":193,"@sentry/core":213,"@sentry/types":228,"@sentry/utils":238,"tslib":312}],198:[function(require,module,exports){
+},{"../eventbuilder":191,"../helpers":193,"@sentry/core":213,"@sentry/types":228,"@sentry/utils":238,"tslib":313}],198:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var globalhandlers_1 = require("./globalhandlers");
 exports.GlobalHandlers = globalhandlers_1.GlobalHandlers;
@@ -27939,7 +27939,7 @@ var LinkedErrors = /** @class */ (function () {
 }());
 exports.LinkedErrors = LinkedErrors;
 
-},{"../parsers":202,"../tracekit":204,"@sentry/core":213,"@sentry/utils":238,"tslib":312}],200:[function(require,module,exports){
+},{"../parsers":202,"../tracekit":204,"@sentry/core":213,"@sentry/utils":238,"tslib":313}],200:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var utils_1 = require("@sentry/utils");
@@ -28171,7 +28171,7 @@ var TryCatch = /** @class */ (function () {
 }());
 exports.TryCatch = TryCatch;
 
-},{"../helpers":193,"@sentry/utils":238,"tslib":312}],201:[function(require,module,exports){
+},{"../helpers":193,"@sentry/utils":238,"tslib":313}],201:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var core_1 = require("@sentry/core");
@@ -28215,7 +28215,7 @@ var UserAgent = /** @class */ (function () {
 }());
 exports.UserAgent = UserAgent;
 
-},{"@sentry/core":213,"@sentry/utils":238,"tslib":312}],202:[function(require,module,exports){
+},{"@sentry/core":213,"@sentry/utils":238,"tslib":313}],202:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var utils_1 = require("@sentry/utils");
 var tracekit_1 = require("./tracekit");
@@ -28540,7 +28540,7 @@ function startSessionTracking() {
     });
 }
 
-},{"./client":190,"./helpers":193,"./integrations":198,"@sentry/core":213,"@sentry/utils":238,"tslib":312}],204:[function(require,module,exports){
+},{"./client":190,"./helpers":193,"./integrations":198,"@sentry/core":213,"@sentry/utils":238,"tslib":313}],204:[function(require,module,exports){
 /**
  * This was originally forked from https://github.com/occ/TraceKit, but has since been
  * largely modified and is now maintained as part of Sentry JS SDK.
@@ -28771,7 +28771,7 @@ function extractMessage(ex) {
     return message;
 }
 
-},{"tslib":312}],205:[function(require,module,exports){
+},{"tslib":313}],205:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var core_1 = require("@sentry/core");
@@ -28898,7 +28898,7 @@ var BaseTransport = /** @class */ (function () {
 }());
 exports.BaseTransport = BaseTransport;
 
-},{"@sentry/core":213,"@sentry/types":228,"@sentry/utils":238,"tslib":312}],206:[function(require,module,exports){
+},{"@sentry/core":213,"@sentry/types":228,"@sentry/utils":238,"tslib":313}],206:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var core_1 = require("@sentry/core");
@@ -29044,7 +29044,7 @@ var FetchTransport = /** @class */ (function (_super) {
 }(base_1.BaseTransport));
 exports.FetchTransport = FetchTransport;
 
-},{"./base":205,"@sentry/core":213,"@sentry/utils":238,"tslib":312}],207:[function(require,module,exports){
+},{"./base":205,"@sentry/core":213,"@sentry/utils":238,"tslib":313}],207:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var base_1 = require("./base");
 exports.BaseTransport = base_1.BaseTransport;
@@ -29117,7 +29117,7 @@ var XHRTransport = /** @class */ (function (_super) {
 }(base_1.BaseTransport));
 exports.XHRTransport = XHRTransport;
 
-},{"./base":205,"@sentry/core":213,"@sentry/utils":238,"tslib":312}],209:[function(require,module,exports){
+},{"./base":205,"@sentry/core":213,"@sentry/utils":238,"tslib":313}],209:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 // TODO: Remove in the next major release and rely only on @sentry/core SDK_VERSION and SdkInfo metadata
 exports.SDK_NAME = 'sentry.javascript.browser';
@@ -29820,7 +29820,7 @@ var BaseClient = /** @class */ (function () {
 }());
 exports.BaseClient = BaseClient;
 
-},{"./integration":214,"@sentry/hub":223,"@sentry/types":228,"@sentry/utils":238,"tslib":312}],213:[function(require,module,exports){
+},{"./integration":214,"@sentry/hub":223,"@sentry/types":228,"@sentry/utils":238,"tslib":313}],213:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var minimal_1 = require("@sentry/minimal");
 exports.addBreadcrumb = minimal_1.addBreadcrumb;
@@ -29932,7 +29932,7 @@ function setupIntegrations(options) {
 }
 exports.setupIntegrations = setupIntegrations;
 
-},{"@sentry/hub":223,"@sentry/utils":238,"tslib":312}],215:[function(require,module,exports){
+},{"@sentry/hub":223,"@sentry/utils":238,"tslib":313}],215:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var originalFunctionToString;
 /** Patch toString calls to return proper name for wrapped functions */
@@ -30142,7 +30142,7 @@ var InboundFilters = /** @class */ (function () {
 }());
 exports.InboundFilters = InboundFilters;
 
-},{"@sentry/hub":223,"@sentry/utils":238,"tslib":312}],217:[function(require,module,exports){
+},{"@sentry/hub":223,"@sentry/utils":238,"tslib":313}],217:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var functiontostring_1 = require("./functiontostring");
 exports.FunctionToString = functiontostring_1.FunctionToString;
@@ -30233,7 +30233,7 @@ function eventToSentryRequest(event, api) {
 }
 exports.eventToSentryRequest = eventToSentryRequest;
 
-},{"tslib":312}],219:[function(require,module,exports){
+},{"tslib":313}],219:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var hub_1 = require("@sentry/hub");
 var utils_1 = require("@sentry/utils");
@@ -30809,7 +30809,7 @@ function setHubOnCarrier(carrier, hub) {
 }
 exports.setHubOnCarrier = setHubOnCarrier;
 
-},{"./scope":224,"./session":225,"@sentry/types":228,"@sentry/utils":238,"tslib":312}],223:[function(require,module,exports){
+},{"./scope":224,"./session":225,"@sentry/types":228,"@sentry/utils":238,"tslib":313}],223:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var scope_1 = require("./scope");
 exports.addGlobalEventProcessor = scope_1.addGlobalEventProcessor;
@@ -31274,7 +31274,7 @@ function addGlobalEventProcessor(callback) {
 }
 exports.addGlobalEventProcessor = addGlobalEventProcessor;
 
-},{"@sentry/utils":238,"tslib":312}],225:[function(require,module,exports){
+},{"@sentry/utils":238,"tslib":313}],225:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var types_1 = require("@sentry/types");
 var utils_1 = require("@sentry/utils");
@@ -31707,7 +31707,7 @@ function startTransaction(context, customSamplingContext) {
 }
 exports.startTransaction = startTransaction;
 
-},{"@sentry/hub":223,"tslib":312}],228:[function(require,module,exports){
+},{"@sentry/hub":223,"tslib":313}],228:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var loglevel_1 = require("./loglevel");
 exports.LogLevel = loglevel_1.LogLevel;
@@ -32074,7 +32074,7 @@ var Dsn = /** @class */ (function () {
 }());
 exports.Dsn = Dsn;
 
-},{"./error":237,"tslib":312}],237:[function(require,module,exports){
+},{"./error":237,"tslib":313}],237:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var polyfill_1 = require("./polyfill");
@@ -32093,7 +32093,7 @@ var SentryError = /** @class */ (function (_super) {
 }(Error));
 exports.SentryError = SentryError;
 
-},{"./polyfill":247,"tslib":312}],238:[function(require,module,exports){
+},{"./polyfill":247,"tslib":313}],238:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./async"), exports);
@@ -32115,7 +32115,7 @@ tslib_1.__exportStar(require("./supports"), exports);
 tslib_1.__exportStar(require("./syncpromise"), exports);
 tslib_1.__exportStar(require("./time"), exports);
 
-},{"./async":234,"./browser":235,"./dsn":236,"./error":237,"./instrument":239,"./is":240,"./logger":241,"./memo":242,"./misc":243,"./node":244,"./object":245,"./path":246,"./promisebuffer":248,"./stacktrace":249,"./string":250,"./supports":251,"./syncpromise":252,"./time":253,"tslib":312}],239:[function(require,module,exports){
+},{"./async":234,"./browser":235,"./dsn":236,"./error":237,"./instrument":239,"./is":240,"./logger":241,"./memo":242,"./misc":243,"./node":244,"./object":245,"./path":246,"./promisebuffer":248,"./stacktrace":249,"./string":250,"./supports":251,"./syncpromise":252,"./time":253,"tslib":313}],239:[function(require,module,exports){
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var is_1 = require("./is");
@@ -32660,7 +32660,7 @@ function instrumentUnhandledRejection() {
     };
 }
 
-},{"./is":240,"./logger":241,"./misc":243,"./object":245,"./stacktrace":249,"./supports":251,"tslib":312}],240:[function(require,module,exports){
+},{"./is":240,"./logger":241,"./misc":243,"./object":245,"./stacktrace":249,"./supports":251,"tslib":313}],240:[function(require,module,exports){
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -33600,7 +33600,7 @@ function dropUndefinedKeys(val) {
 exports.dropUndefinedKeys = dropUndefinedKeys;
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./browser":235,"./is":240,"./memo":242,"./stacktrace":249,"./string":250,"tslib":312}],246:[function(require,module,exports){
+},{"./browser":235,"./is":240,"./memo":242,"./stacktrace":249,"./string":250,"tslib":313}],246:[function(require,module,exports){
 // Slightly modified (no IE8 support, ES6) and transcribed to TypeScript
 // https://raw.githubusercontent.com/calvinmetcalf/rollup-plugin-node-builtins/master/src/es6/path.js
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -45707,6 +45707,1406 @@ return Dexie;
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
 },{"timers":186}],289:[function(require,module,exports){
+/*! @license DOMPurify 2.3.3 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.3.3/LICENSE */
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = global || self, global.DOMPurify = factory());
+}(this, function () { 'use strict';
+
+  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+  var hasOwnProperty = Object.hasOwnProperty,
+      setPrototypeOf = Object.setPrototypeOf,
+      isFrozen = Object.isFrozen,
+      getPrototypeOf = Object.getPrototypeOf,
+      getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  var freeze = Object.freeze,
+      seal = Object.seal,
+      create = Object.create; // eslint-disable-line import/no-mutable-exports
+
+  var _ref = typeof Reflect !== 'undefined' && Reflect,
+      apply = _ref.apply,
+      construct = _ref.construct;
+
+  if (!apply) {
+    apply = function apply(fun, thisValue, args) {
+      return fun.apply(thisValue, args);
+    };
+  }
+
+  if (!freeze) {
+    freeze = function freeze(x) {
+      return x;
+    };
+  }
+
+  if (!seal) {
+    seal = function seal(x) {
+      return x;
+    };
+  }
+
+  if (!construct) {
+    construct = function construct(Func, args) {
+      return new (Function.prototype.bind.apply(Func, [null].concat(_toConsumableArray(args))))();
+    };
+  }
+
+  var arrayForEach = unapply(Array.prototype.forEach);
+  var arrayPop = unapply(Array.prototype.pop);
+  var arrayPush = unapply(Array.prototype.push);
+
+  var stringToLowerCase = unapply(String.prototype.toLowerCase);
+  var stringMatch = unapply(String.prototype.match);
+  var stringReplace = unapply(String.prototype.replace);
+  var stringIndexOf = unapply(String.prototype.indexOf);
+  var stringTrim = unapply(String.prototype.trim);
+
+  var regExpTest = unapply(RegExp.prototype.test);
+
+  var typeErrorCreate = unconstruct(TypeError);
+
+  function unapply(func) {
+    return function (thisArg) {
+      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      return apply(func, thisArg, args);
+    };
+  }
+
+  function unconstruct(func) {
+    return function () {
+      for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      return construct(func, args);
+    };
+  }
+
+  /* Add properties to a lookup table */
+  function addToSet(set, array) {
+    if (setPrototypeOf) {
+      // Make 'in' and truthy checks like Boolean(set.constructor)
+      // independent of any properties defined on Object.prototype.
+      // Prevent prototype setters from intercepting set as a this value.
+      setPrototypeOf(set, null);
+    }
+
+    var l = array.length;
+    while (l--) {
+      var element = array[l];
+      if (typeof element === 'string') {
+        var lcElement = stringToLowerCase(element);
+        if (lcElement !== element) {
+          // Config presets (e.g. tags.js, attrs.js) are immutable.
+          if (!isFrozen(array)) {
+            array[l] = lcElement;
+          }
+
+          element = lcElement;
+        }
+      }
+
+      set[element] = true;
+    }
+
+    return set;
+  }
+
+  /* Shallow clone an object */
+  function clone(object) {
+    var newObject = create(null);
+
+    var property = void 0;
+    for (property in object) {
+      if (apply(hasOwnProperty, object, [property])) {
+        newObject[property] = object[property];
+      }
+    }
+
+    return newObject;
+  }
+
+  /* IE10 doesn't support __lookupGetter__ so lets'
+   * simulate it. It also automatically checks
+   * if the prop is function or getter and behaves
+   * accordingly. */
+  function lookupGetter(object, prop) {
+    while (object !== null) {
+      var desc = getOwnPropertyDescriptor(object, prop);
+      if (desc) {
+        if (desc.get) {
+          return unapply(desc.get);
+        }
+
+        if (typeof desc.value === 'function') {
+          return unapply(desc.value);
+        }
+      }
+
+      object = getPrototypeOf(object);
+    }
+
+    function fallbackValue(element) {
+      console.warn('fallback value for', element);
+      return null;
+    }
+
+    return fallbackValue;
+  }
+
+  var html = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
+
+  // SVG
+  var svg = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
+
+  var svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
+
+  // List of SVG elements that are disallowed by default.
+  // We still need to know them so that we can do namespace
+  // checks properly in case one wants to add them to
+  // allow-list.
+  var svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'fedropshadow', 'feimage', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
+
+  var mathMl = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover']);
+
+  // Similarly to SVG, we want to know all MathML elements,
+  // even those that we disallow by default.
+  var mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
+
+  var text = freeze(['#text']);
+
+  var html$1 = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns', 'slot']);
+
+  var svg$1 = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
+
+  var mathMl$1 = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
+
+  var xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
+
+  // eslint-disable-next-line unicorn/better-regex
+  var MUSTACHE_EXPR = seal(/\{\{[\s\S]*|[\s\S]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
+  var ERB_EXPR = seal(/<%[\s\S]*|[\s\S]*%>/gm);
+  var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/); // eslint-disable-line no-useless-escape
+  var ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
+  var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
+  );
+  var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+  var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex
+  );
+
+  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+  function _toConsumableArray$1(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+  var getGlobal = function getGlobal() {
+    return typeof window === 'undefined' ? null : window;
+  };
+
+  /**
+   * Creates a no-op policy for internal use only.
+   * Don't export this function outside this module!
+   * @param {?TrustedTypePolicyFactory} trustedTypes The policy factory.
+   * @param {Document} document The document object (to determine policy name suffix)
+   * @return {?TrustedTypePolicy} The policy created (or null, if Trusted Types
+   * are not supported).
+   */
+  var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, document) {
+    if ((typeof trustedTypes === 'undefined' ? 'undefined' : _typeof(trustedTypes)) !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
+      return null;
+    }
+
+    // Allow the callers to control the unique policy name
+    // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
+    // Policy creation with duplicate names throws in Trusted Types.
+    var suffix = null;
+    var ATTR_NAME = 'data-tt-policy-suffix';
+    if (document.currentScript && document.currentScript.hasAttribute(ATTR_NAME)) {
+      suffix = document.currentScript.getAttribute(ATTR_NAME);
+    }
+
+    var policyName = 'dompurify' + (suffix ? '#' + suffix : '');
+
+    try {
+      return trustedTypes.createPolicy(policyName, {
+        createHTML: function createHTML(html$$1) {
+          return html$$1;
+        }
+      });
+    } catch (_) {
+      // Policy creation failed (most likely another DOMPurify script has
+      // already run). Skip creating the policy, as this will only cause errors
+      // if TT are enforced.
+      console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
+      return null;
+    }
+  };
+
+  function createDOMPurify() {
+    var window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
+
+    var DOMPurify = function DOMPurify(root) {
+      return createDOMPurify(root);
+    };
+
+    /**
+     * Version label, exposed for easier checks
+     * if DOMPurify is up to date or not
+     */
+    DOMPurify.version = '2.3.3';
+
+    /**
+     * Array of elements that DOMPurify removed during sanitation.
+     * Empty if nothing was removed.
+     */
+    DOMPurify.removed = [];
+
+    if (!window || !window.document || window.document.nodeType !== 9) {
+      // Not running in a browser, provide a factory function
+      // so that you can pass your own Window
+      DOMPurify.isSupported = false;
+
+      return DOMPurify;
+    }
+
+    var originalDocument = window.document;
+
+    var document = window.document;
+    var DocumentFragment = window.DocumentFragment,
+        HTMLTemplateElement = window.HTMLTemplateElement,
+        Node = window.Node,
+        Element = window.Element,
+        NodeFilter = window.NodeFilter,
+        _window$NamedNodeMap = window.NamedNodeMap,
+        NamedNodeMap = _window$NamedNodeMap === undefined ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap,
+        Text = window.Text,
+        Comment = window.Comment,
+        DOMParser = window.DOMParser,
+        trustedTypes = window.trustedTypes;
+
+
+    var ElementPrototype = Element.prototype;
+
+    var cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
+    var getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
+    var getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
+    var getParentNode = lookupGetter(ElementPrototype, 'parentNode');
+
+    // As per issue #47, the web-components registry is inherited by a
+    // new document created via createHTMLDocument. As per the spec
+    // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
+    // a new empty registry is used when creating a template contents owner
+    // document, so we use that as our parent document to ensure nothing
+    // is inherited.
+    if (typeof HTMLTemplateElement === 'function') {
+      var template = document.createElement('template');
+      if (template.content && template.content.ownerDocument) {
+        document = template.content.ownerDocument;
+      }
+    }
+
+    var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);
+    var emptyHTML = trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML('') : '';
+
+    var _document = document,
+        implementation = _document.implementation,
+        createNodeIterator = _document.createNodeIterator,
+        createDocumentFragment = _document.createDocumentFragment,
+        getElementsByTagName = _document.getElementsByTagName;
+    var importNode = originalDocument.importNode;
+
+
+    var documentMode = {};
+    try {
+      documentMode = clone(document).documentMode ? document.documentMode : {};
+    } catch (_) {}
+
+    var hooks = {};
+
+    /**
+     * Expose whether this browser supports running the full DOMPurify.
+     */
+    DOMPurify.isSupported = typeof getParentNode === 'function' && implementation && typeof implementation.createHTMLDocument !== 'undefined' && documentMode !== 9;
+
+    var MUSTACHE_EXPR$$1 = MUSTACHE_EXPR,
+        ERB_EXPR$$1 = ERB_EXPR,
+        DATA_ATTR$$1 = DATA_ATTR,
+        ARIA_ATTR$$1 = ARIA_ATTR,
+        IS_SCRIPT_OR_DATA$$1 = IS_SCRIPT_OR_DATA,
+        ATTR_WHITESPACE$$1 = ATTR_WHITESPACE;
+    var IS_ALLOWED_URI$$1 = IS_ALLOWED_URI;
+
+    /**
+     * We consider the elements and attributes below to be safe. Ideally
+     * don't add any new ones but feel free to remove unwanted ones.
+     */
+
+    /* allowed element names */
+
+    var ALLOWED_TAGS = null;
+    var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(html), _toConsumableArray$1(svg), _toConsumableArray$1(svgFilters), _toConsumableArray$1(mathMl), _toConsumableArray$1(text)));
+
+    /* Allowed attribute names */
+    var ALLOWED_ATTR = null;
+    var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray$1(html$1), _toConsumableArray$1(svg$1), _toConsumableArray$1(mathMl$1), _toConsumableArray$1(xml)));
+
+    /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
+    var FORBID_TAGS = null;
+
+    /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
+    var FORBID_ATTR = null;
+
+    /* Decide if ARIA attributes are okay */
+    var ALLOW_ARIA_ATTR = true;
+
+    /* Decide if custom data attributes are okay */
+    var ALLOW_DATA_ATTR = true;
+
+    /* Decide if unknown protocols are okay */
+    var ALLOW_UNKNOWN_PROTOCOLS = false;
+
+    /* Output should be safe for common template engines.
+     * This means, DOMPurify removes data attributes, mustaches and ERB
+     */
+    var SAFE_FOR_TEMPLATES = false;
+
+    /* Decide if document with <html>... should be returned */
+    var WHOLE_DOCUMENT = false;
+
+    /* Track whether config is already set on this instance of DOMPurify. */
+    var SET_CONFIG = false;
+
+    /* Decide if all elements (e.g. style, script) must be children of
+     * document.body. By default, browsers might move them to document.head */
+    var FORCE_BODY = false;
+
+    /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
+     * string (or a TrustedHTML object if Trusted Types are supported).
+     * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
+     */
+    var RETURN_DOM = false;
+
+    /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
+     * string  (or a TrustedHTML object if Trusted Types are supported) */
+    var RETURN_DOM_FRAGMENT = false;
+
+    /* If `RETURN_DOM` or `RETURN_DOM_FRAGMENT` is enabled, decide if the returned DOM
+     * `Node` is imported into the current `Document`. If this flag is not enabled the
+     * `Node` will belong (its ownerDocument) to a fresh `HTMLDocument`, created by
+     * DOMPurify.
+     *
+     * This defaults to `true` starting DOMPurify 2.2.0. Note that setting it to `false`
+     * might cause XSS from attacks hidden in closed shadowroots in case the browser
+     * supports Declarative Shadow: DOM https://web.dev/declarative-shadow-dom/
+     */
+    var RETURN_DOM_IMPORT = true;
+
+    /* Try to return a Trusted Type object instead of a string, return a string in
+     * case Trusted Types are not supported  */
+    var RETURN_TRUSTED_TYPE = false;
+
+    /* Output should be free from DOM clobbering attacks? */
+    var SANITIZE_DOM = true;
+
+    /* Keep element content when removing element? */
+    var KEEP_CONTENT = true;
+
+    /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
+     * of importing it into a new Document and returning a sanitized copy */
+    var IN_PLACE = false;
+
+    /* Allow usage of profiles like html, svg and mathMl */
+    var USE_PROFILES = {};
+
+    /* Tags to ignore content of when KEEP_CONTENT is true */
+    var FORBID_CONTENTS = null;
+    var DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
+
+    /* Tags that are safe for data: URIs */
+    var DATA_URI_TAGS = null;
+    var DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
+
+    /* Attributes safe for values like "javascript:" */
+    var URI_SAFE_ATTRIBUTES = null;
+    var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
+
+    var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+    var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+    var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+    /* Document namespace */
+    var NAMESPACE = HTML_NAMESPACE;
+    var IS_EMPTY_INPUT = false;
+
+    /* Parsing of strict XHTML documents */
+    var PARSER_MEDIA_TYPE = void 0;
+    var SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];
+    var DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
+    var transformCaseFunc = void 0;
+
+    /* Keep a reference to config to pass to hooks */
+    var CONFIG = null;
+
+    /* Ideally, do not touch anything below this line */
+    /* ______________________________________________ */
+
+    var formElement = document.createElement('form');
+
+    /**
+     * _parseConfig
+     *
+     * @param  {Object} cfg optional config literal
+     */
+    // eslint-disable-next-line complexity
+    var _parseConfig = function _parseConfig(cfg) {
+      if (CONFIG && CONFIG === cfg) {
+        return;
+      }
+
+      /* Shield configuration object from tampering */
+      if (!cfg || (typeof cfg === 'undefined' ? 'undefined' : _typeof(cfg)) !== 'object') {
+        cfg = {};
+      }
+
+      /* Shield configuration object from prototype pollution */
+      cfg = clone(cfg);
+
+      /* Set configuration parameters */
+      ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS;
+      ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR;
+      URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES;
+      DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS;
+      FORBID_CONTENTS = 'FORBID_CONTENTS' in cfg ? addToSet({}, cfg.FORBID_CONTENTS) : DEFAULT_FORBID_CONTENTS;
+      FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS) : {};
+      FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR) : {};
+      USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;
+      ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true
+      ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true
+      ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false
+      SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false
+      WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false
+      RETURN_DOM = cfg.RETURN_DOM || false; // Default false
+      RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false
+      RETURN_DOM_IMPORT = cfg.RETURN_DOM_IMPORT !== false; // Default true
+      RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false
+      FORCE_BODY = cfg.FORCE_BODY || false; // Default false
+      SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true
+      KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true
+      IN_PLACE = cfg.IN_PLACE || false; // Default false
+      IS_ALLOWED_URI$$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$$1;
+      NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+
+      PARSER_MEDIA_TYPE =
+      // eslint-disable-next-line unicorn/prefer-includes
+      SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? PARSER_MEDIA_TYPE = DEFAULT_PARSER_MEDIA_TYPE : PARSER_MEDIA_TYPE = cfg.PARSER_MEDIA_TYPE;
+
+      // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
+      transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? function (x) {
+        return x;
+      } : stringToLowerCase;
+
+      if (SAFE_FOR_TEMPLATES) {
+        ALLOW_DATA_ATTR = false;
+      }
+
+      if (RETURN_DOM_FRAGMENT) {
+        RETURN_DOM = true;
+      }
+
+      /* Parse profile info */
+      if (USE_PROFILES) {
+        ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(text)));
+        ALLOWED_ATTR = [];
+        if (USE_PROFILES.html === true) {
+          addToSet(ALLOWED_TAGS, html);
+          addToSet(ALLOWED_ATTR, html$1);
+        }
+
+        if (USE_PROFILES.svg === true) {
+          addToSet(ALLOWED_TAGS, svg);
+          addToSet(ALLOWED_ATTR, svg$1);
+          addToSet(ALLOWED_ATTR, xml);
+        }
+
+        if (USE_PROFILES.svgFilters === true) {
+          addToSet(ALLOWED_TAGS, svgFilters);
+          addToSet(ALLOWED_ATTR, svg$1);
+          addToSet(ALLOWED_ATTR, xml);
+        }
+
+        if (USE_PROFILES.mathMl === true) {
+          addToSet(ALLOWED_TAGS, mathMl);
+          addToSet(ALLOWED_ATTR, mathMl$1);
+          addToSet(ALLOWED_ATTR, xml);
+        }
+      }
+
+      /* Merge configuration parameters */
+      if (cfg.ADD_TAGS) {
+        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+          ALLOWED_TAGS = clone(ALLOWED_TAGS);
+        }
+
+        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS);
+      }
+
+      if (cfg.ADD_ATTR) {
+        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+          ALLOWED_ATTR = clone(ALLOWED_ATTR);
+        }
+
+        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR);
+      }
+
+      if (cfg.ADD_URI_SAFE_ATTR) {
+        addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR);
+      }
+
+      if (cfg.FORBID_CONTENTS) {
+        if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+          FORBID_CONTENTS = clone(FORBID_CONTENTS);
+        }
+
+        addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS);
+      }
+
+      /* Add #text in case KEEP_CONTENT is set to true */
+      if (KEEP_CONTENT) {
+        ALLOWED_TAGS['#text'] = true;
+      }
+
+      /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
+      if (WHOLE_DOCUMENT) {
+        addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);
+      }
+
+      /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
+      if (ALLOWED_TAGS.table) {
+        addToSet(ALLOWED_TAGS, ['tbody']);
+        delete FORBID_TAGS.tbody;
+      }
+
+      // Prevent further manipulation of configuration.
+      // Not available in IE8, Safari 5, etc.
+      if (freeze) {
+        freeze(cfg);
+      }
+
+      CONFIG = cfg;
+    };
+
+    var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
+
+    var HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'desc', 'title', 'annotation-xml']);
+
+    /* Keep track of all possible SVG and MathML tags
+     * so that we can perform the namespace checks
+     * correctly. */
+    var ALL_SVG_TAGS = addToSet({}, svg);
+    addToSet(ALL_SVG_TAGS, svgFilters);
+    addToSet(ALL_SVG_TAGS, svgDisallowed);
+
+    var ALL_MATHML_TAGS = addToSet({}, mathMl);
+    addToSet(ALL_MATHML_TAGS, mathMlDisallowed);
+
+    /**
+     *
+     *
+     * @param  {Element} element a DOM element whose namespace is being checked
+     * @returns {boolean} Return false if the element has a
+     *  namespace that a spec-compliant parser would never
+     *  return. Return true otherwise.
+     */
+    var _checkValidNamespace = function _checkValidNamespace(element) {
+      var parent = getParentNode(element);
+
+      // In JSDOM, if we're inside shadow DOM, then parentNode
+      // can be null. We just simulate parent in this case.
+      if (!parent || !parent.tagName) {
+        parent = {
+          namespaceURI: HTML_NAMESPACE,
+          tagName: 'template'
+        };
+      }
+
+      var tagName = stringToLowerCase(element.tagName);
+      var parentTagName = stringToLowerCase(parent.tagName);
+
+      if (element.namespaceURI === SVG_NAMESPACE) {
+        // The only way to switch from HTML namespace to SVG
+        // is via <svg>. If it happens via any other tag, then
+        // it should be killed.
+        if (parent.namespaceURI === HTML_NAMESPACE) {
+          return tagName === 'svg';
+        }
+
+        // The only way to switch from MathML to SVG is via
+        // svg if parent is either <annotation-xml> or MathML
+        // text integration points.
+        if (parent.namespaceURI === MATHML_NAMESPACE) {
+          return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+        }
+
+        // We only allow elements that are defined in SVG
+        // spec. All others are disallowed in SVG namespace.
+        return Boolean(ALL_SVG_TAGS[tagName]);
+      }
+
+      if (element.namespaceURI === MATHML_NAMESPACE) {
+        // The only way to switch from HTML namespace to MathML
+        // is via <math>. If it happens via any other tag, then
+        // it should be killed.
+        if (parent.namespaceURI === HTML_NAMESPACE) {
+          return tagName === 'math';
+        }
+
+        // The only way to switch from SVG to MathML is via
+        // <math> and HTML integration points
+        if (parent.namespaceURI === SVG_NAMESPACE) {
+          return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
+        }
+
+        // We only allow elements that are defined in MathML
+        // spec. All others are disallowed in MathML namespace.
+        return Boolean(ALL_MATHML_TAGS[tagName]);
+      }
+
+      if (element.namespaceURI === HTML_NAMESPACE) {
+        // The only way to switch from SVG to HTML is via
+        // HTML integration points, and from MathML to HTML
+        // is via MathML text integration points
+        if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+          return false;
+        }
+
+        if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+          return false;
+        }
+
+        // Certain elements are allowed in both SVG and HTML
+        // namespace. We need to specify them explicitly
+        // so that they don't get erronously deleted from
+        // HTML namespace.
+        var commonSvgAndHTMLElements = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
+
+        // We disallow tags that are specific for MathML
+        // or SVG and should never appear in HTML namespace
+        return !ALL_MATHML_TAGS[tagName] && (commonSvgAndHTMLElements[tagName] || !ALL_SVG_TAGS[tagName]);
+      }
+
+      // The code should never reach this place (this means
+      // that the element somehow got namespace that is not
+      // HTML, SVG or MathML). Return false just in case.
+      return false;
+    };
+
+    /**
+     * _forceRemove
+     *
+     * @param  {Node} node a DOM node
+     */
+    var _forceRemove = function _forceRemove(node) {
+      arrayPush(DOMPurify.removed, { element: node });
+      try {
+        // eslint-disable-next-line unicorn/prefer-dom-node-remove
+        node.parentNode.removeChild(node);
+      } catch (_) {
+        try {
+          node.outerHTML = emptyHTML;
+        } catch (_) {
+          node.remove();
+        }
+      }
+    };
+
+    /**
+     * _removeAttribute
+     *
+     * @param  {String} name an Attribute name
+     * @param  {Node} node a DOM node
+     */
+    var _removeAttribute = function _removeAttribute(name, node) {
+      try {
+        arrayPush(DOMPurify.removed, {
+          attribute: node.getAttributeNode(name),
+          from: node
+        });
+      } catch (_) {
+        arrayPush(DOMPurify.removed, {
+          attribute: null,
+          from: node
+        });
+      }
+
+      node.removeAttribute(name);
+
+      // We void attribute values for unremovable "is"" attributes
+      if (name === 'is' && !ALLOWED_ATTR[name]) {
+        if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+          try {
+            _forceRemove(node);
+          } catch (_) {}
+        } else {
+          try {
+            node.setAttribute(name, '');
+          } catch (_) {}
+        }
+      }
+    };
+
+    /**
+     * _initDocument
+     *
+     * @param  {String} dirty a string of dirty markup
+     * @return {Document} a DOM, filled with the dirty markup
+     */
+    var _initDocument = function _initDocument(dirty) {
+      /* Create a HTML document */
+      var doc = void 0;
+      var leadingWhitespace = void 0;
+
+      if (FORCE_BODY) {
+        dirty = '<remove></remove>' + dirty;
+      } else {
+        /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
+        var matches = stringMatch(dirty, /^[\r\n\t ]+/);
+        leadingWhitespace = matches && matches[0];
+      }
+
+      if (PARSER_MEDIA_TYPE === 'application/xhtml+xml') {
+        // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)
+        dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + '</body></html>';
+      }
+
+      var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+      /*
+       * Use the DOMParser API by default, fallback later if needs be
+       * DOMParser not work for svg when has multiple root element.
+       */
+      if (NAMESPACE === HTML_NAMESPACE) {
+        try {
+          doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+        } catch (_) {}
+      }
+
+      /* Use createHTMLDocument in case DOMParser is not available */
+      if (!doc || !doc.documentElement) {
+        doc = implementation.createDocument(NAMESPACE, 'template', null);
+        try {
+          doc.documentElement.innerHTML = IS_EMPTY_INPUT ? '' : dirtyPayload;
+        } catch (_) {
+          // Syntax error if dirtyPayload is invalid xml
+        }
+      }
+
+      var body = doc.body || doc.documentElement;
+
+      if (dirty && leadingWhitespace) {
+        body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+      }
+
+      /* Work on whole document or just its body */
+      if (NAMESPACE === HTML_NAMESPACE) {
+        return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
+      }
+
+      return WHOLE_DOCUMENT ? doc.documentElement : body;
+    };
+
+    /**
+     * _createIterator
+     *
+     * @param  {Document} root document/fragment to create iterator for
+     * @return {Iterator} iterator instance
+     */
+    var _createIterator = function _createIterator(root) {
+      return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, null, false);
+    };
+
+    /**
+     * _isClobbered
+     *
+     * @param  {Node} elm element to check for clobbering attacks
+     * @return {Boolean} true if clobbered, false if safe
+     */
+    var _isClobbered = function _isClobbered(elm) {
+      if (elm instanceof Text || elm instanceof Comment) {
+        return false;
+      }
+
+      if (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function') {
+        return true;
+      }
+
+      return false;
+    };
+
+    /**
+     * _isNode
+     *
+     * @param  {Node} obj object to check whether it's a DOM node
+     * @return {Boolean} true is object is a DOM node
+     */
+    var _isNode = function _isNode(object) {
+      return (typeof Node === 'undefined' ? 'undefined' : _typeof(Node)) === 'object' ? object instanceof Node : object && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';
+    };
+
+    /**
+     * _executeHook
+     * Execute user configurable hooks
+     *
+     * @param  {String} entryPoint  Name of the hook's entry point
+     * @param  {Node} currentNode node to work on with the hook
+     * @param  {Object} data additional hook parameters
+     */
+    var _executeHook = function _executeHook(entryPoint, currentNode, data) {
+      if (!hooks[entryPoint]) {
+        return;
+      }
+
+      arrayForEach(hooks[entryPoint], function (hook) {
+        hook.call(DOMPurify, currentNode, data, CONFIG);
+      });
+    };
+
+    /**
+     * _sanitizeElements
+     *
+     * @protect nodeName
+     * @protect textContent
+     * @protect removeChild
+     *
+     * @param   {Node} currentNode to check for permission to exist
+     * @return  {Boolean} true if node was killed, false if left alive
+     */
+    var _sanitizeElements = function _sanitizeElements(currentNode) {
+      var content = void 0;
+
+      /* Execute a hook if present */
+      _executeHook('beforeSanitizeElements', currentNode, null);
+
+      /* Check if element is clobbered or can clobber */
+      if (_isClobbered(currentNode)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Check if tagname contains Unicode */
+      if (stringMatch(currentNode.nodeName, /[\u0080-\uFFFF]/)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Now let's check the element's type and name */
+      var tagName = transformCaseFunc(currentNode.nodeName);
+
+      /* Execute a hook if present */
+      _executeHook('uponSanitizeElement', currentNode, {
+        tagName: tagName,
+        allowedTags: ALLOWED_TAGS
+      });
+
+      /* Detect mXSS attempts abusing namespace confusion */
+      if (!_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Mitigate a problem with templates inside select */
+      if (tagName === 'select' && regExpTest(/<template/i, currentNode.innerHTML)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Remove element if anything forbids its presence */
+      if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+        /* Keep content except for bad-listed elements */
+        if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+          var parentNode = getParentNode(currentNode) || currentNode.parentNode;
+          var childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+
+          if (childNodes && parentNode) {
+            var childCount = childNodes.length;
+
+            for (var i = childCount - 1; i >= 0; --i) {
+              parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));
+            }
+          }
+        }
+
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Check whether element has a valid namespace */
+      if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      if ((tagName === 'noscript' || tagName === 'noembed') && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) {
+        _forceRemove(currentNode);
+        return true;
+      }
+
+      /* Sanitize element content to be template-safe */
+      if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {
+        /* Get the element's text content */
+        content = currentNode.textContent;
+        content = stringReplace(content, MUSTACHE_EXPR$$1, ' ');
+        content = stringReplace(content, ERB_EXPR$$1, ' ');
+        if (currentNode.textContent !== content) {
+          arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
+          currentNode.textContent = content;
+        }
+      }
+
+      /* Execute a hook if present */
+      _executeHook('afterSanitizeElements', currentNode, null);
+
+      return false;
+    };
+
+    /**
+     * _isValidAttribute
+     *
+     * @param  {string} lcTag Lowercase tag name of containing element.
+     * @param  {string} lcName Lowercase attribute name.
+     * @param  {string} value Attribute value.
+     * @return {Boolean} Returns true if `value` is valid, otherwise false.
+     */
+    // eslint-disable-next-line complexity
+    var _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
+      /* Make sure attribute cannot clobber */
+      if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
+        return false;
+      }
+
+      /* Allow valid data-* attributes: At least one character after "-"
+          (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
+          XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
+          We don't need to check the value; it's always URI safe. */
+      if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$$1, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$$1, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+        return false;
+
+        /* Check value is safe. First, is attr inert? If so, is safe */
+      } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if (!value) ; else {
+        return false;
+      }
+
+      return true;
+    };
+
+    /**
+     * _sanitizeAttributes
+     *
+     * @protect attributes
+     * @protect nodeName
+     * @protect removeAttribute
+     * @protect setAttribute
+     *
+     * @param  {Node} currentNode to sanitize
+     */
+    var _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
+      var attr = void 0;
+      var value = void 0;
+      var lcName = void 0;
+      var l = void 0;
+      /* Execute a hook if present */
+      _executeHook('beforeSanitizeAttributes', currentNode, null);
+
+      var attributes = currentNode.attributes;
+
+      /* Check if we have attributes; if not we might have a text node */
+
+      if (!attributes) {
+        return;
+      }
+
+      var hookEvent = {
+        attrName: '',
+        attrValue: '',
+        keepAttr: true,
+        allowedAttributes: ALLOWED_ATTR
+      };
+      l = attributes.length;
+
+      /* Go backwards over all attributes; safely remove bad ones */
+      while (l--) {
+        attr = attributes[l];
+        var _attr = attr,
+            name = _attr.name,
+            namespaceURI = _attr.namespaceURI;
+
+        value = stringTrim(attr.value);
+        lcName = transformCaseFunc(name);
+
+        /* Execute a hook if present */
+        hookEvent.attrName = lcName;
+        hookEvent.attrValue = value;
+        hookEvent.keepAttr = true;
+        hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
+        _executeHook('uponSanitizeAttribute', currentNode, hookEvent);
+        value = hookEvent.attrValue;
+        /* Did the hooks approve of the attribute? */
+        if (hookEvent.forceKeepAttr) {
+          continue;
+        }
+
+        /* Remove attribute */
+        _removeAttribute(name, currentNode);
+
+        /* Did the hooks approve of the attribute? */
+        if (!hookEvent.keepAttr) {
+          continue;
+        }
+
+        /* Work around a security issue in jQuery 3.0 */
+        if (regExpTest(/\/>/i, value)) {
+          _removeAttribute(name, currentNode);
+          continue;
+        }
+
+        /* Sanitize attribute content to be template-safe */
+        if (SAFE_FOR_TEMPLATES) {
+          value = stringReplace(value, MUSTACHE_EXPR$$1, ' ');
+          value = stringReplace(value, ERB_EXPR$$1, ' ');
+        }
+
+        /* Is `value` valid for this attribute? */
+        var lcTag = transformCaseFunc(currentNode.nodeName);
+        if (!_isValidAttribute(lcTag, lcName, value)) {
+          continue;
+        }
+
+        /* Handle invalid data-* attribute set by try-catching it */
+        try {
+          if (namespaceURI) {
+            currentNode.setAttributeNS(namespaceURI, name, value);
+          } else {
+            /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
+            currentNode.setAttribute(name, value);
+          }
+
+          arrayPop(DOMPurify.removed);
+        } catch (_) {}
+      }
+
+      /* Execute a hook if present */
+      _executeHook('afterSanitizeAttributes', currentNode, null);
+    };
+
+    /**
+     * _sanitizeShadowDOM
+     *
+     * @param  {DocumentFragment} fragment to iterate over recursively
+     */
+    var _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
+      var shadowNode = void 0;
+      var shadowIterator = _createIterator(fragment);
+
+      /* Execute a hook if present */
+      _executeHook('beforeSanitizeShadowDOM', fragment, null);
+
+      while (shadowNode = shadowIterator.nextNode()) {
+        /* Execute a hook if present */
+        _executeHook('uponSanitizeShadowNode', shadowNode, null);
+
+        /* Sanitize tags and elements */
+        if (_sanitizeElements(shadowNode)) {
+          continue;
+        }
+
+        /* Deep shadow DOM detected */
+        if (shadowNode.content instanceof DocumentFragment) {
+          _sanitizeShadowDOM(shadowNode.content);
+        }
+
+        /* Check attributes, sanitize if necessary */
+        _sanitizeAttributes(shadowNode);
+      }
+
+      /* Execute a hook if present */
+      _executeHook('afterSanitizeShadowDOM', fragment, null);
+    };
+
+    /**
+     * Sanitize
+     * Public method providing core sanitation functionality
+     *
+     * @param {String|Node} dirty string or DOM node
+     * @param {Object} configuration object
+     */
+    // eslint-disable-next-line complexity
+    DOMPurify.sanitize = function (dirty, cfg) {
+      var body = void 0;
+      var importedNode = void 0;
+      var currentNode = void 0;
+      var oldNode = void 0;
+      var returnNode = void 0;
+      /* Make sure we have a string to sanitize.
+        DO NOT return early, as this will return the wrong type if
+        the user has requested a DOM object rather than a string */
+      IS_EMPTY_INPUT = !dirty;
+      if (IS_EMPTY_INPUT) {
+        dirty = '<!-->';
+      }
+
+      /* Stringify, in case dirty is an object */
+      if (typeof dirty !== 'string' && !_isNode(dirty)) {
+        // eslint-disable-next-line no-negated-condition
+        if (typeof dirty.toString !== 'function') {
+          throw typeErrorCreate('toString is not a function');
+        } else {
+          dirty = dirty.toString();
+          if (typeof dirty !== 'string') {
+            throw typeErrorCreate('dirty is not a string, aborting');
+          }
+        }
+      }
+
+      /* Check we can run. Otherwise fall back or ignore */
+      if (!DOMPurify.isSupported) {
+        if (_typeof(window.toStaticHTML) === 'object' || typeof window.toStaticHTML === 'function') {
+          if (typeof dirty === 'string') {
+            return window.toStaticHTML(dirty);
+          }
+
+          if (_isNode(dirty)) {
+            return window.toStaticHTML(dirty.outerHTML);
+          }
+        }
+
+        return dirty;
+      }
+
+      /* Assign config vars */
+      if (!SET_CONFIG) {
+        _parseConfig(cfg);
+      }
+
+      /* Clean up removed elements */
+      DOMPurify.removed = [];
+
+      /* Check if dirty is correctly typed for IN_PLACE */
+      if (typeof dirty === 'string') {
+        IN_PLACE = false;
+      }
+
+      if (IN_PLACE) ; else if (dirty instanceof Node) {
+        /* If dirty is a DOM element, append to an empty document to avoid
+           elements being stripped by the parser */
+        body = _initDocument('<!---->');
+        importedNode = body.ownerDocument.importNode(dirty, true);
+        if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {
+          /* Node is already a body, use as is */
+          body = importedNode;
+        } else if (importedNode.nodeName === 'HTML') {
+          body = importedNode;
+        } else {
+          // eslint-disable-next-line unicorn/prefer-dom-node-append
+          body.appendChild(importedNode);
+        }
+      } else {
+        /* Exit directly if we have nothing to do */
+        if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&
+        // eslint-disable-next-line unicorn/prefer-includes
+        dirty.indexOf('<') === -1) {
+          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+        }
+
+        /* Initialize the document to work on */
+        body = _initDocument(dirty);
+
+        /* Check we have a DOM node from the data */
+        if (!body) {
+          return RETURN_DOM ? null : emptyHTML;
+        }
+      }
+
+      /* Remove first element node (ours) if FORCE_BODY is set */
+      if (body && FORCE_BODY) {
+        _forceRemove(body.firstChild);
+      }
+
+      /* Get node iterator */
+      var nodeIterator = _createIterator(IN_PLACE ? dirty : body);
+
+      /* Now start iterating over the created document */
+      while (currentNode = nodeIterator.nextNode()) {
+        /* Fix IE's strange behavior with manipulated textNodes #89 */
+        if (currentNode.nodeType === 3 && currentNode === oldNode) {
+          continue;
+        }
+
+        /* Sanitize tags and elements */
+        if (_sanitizeElements(currentNode)) {
+          continue;
+        }
+
+        /* Shadow DOM detected, sanitize it */
+        if (currentNode.content instanceof DocumentFragment) {
+          _sanitizeShadowDOM(currentNode.content);
+        }
+
+        /* Check attributes, sanitize if necessary */
+        _sanitizeAttributes(currentNode);
+
+        oldNode = currentNode;
+      }
+
+      oldNode = null;
+
+      /* If we sanitized `dirty` in-place, return it. */
+      if (IN_PLACE) {
+        return dirty;
+      }
+
+      /* Return sanitized string or DOM */
+      if (RETURN_DOM) {
+        if (RETURN_DOM_FRAGMENT) {
+          returnNode = createDocumentFragment.call(body.ownerDocument);
+
+          while (body.firstChild) {
+            // eslint-disable-next-line unicorn/prefer-dom-node-append
+            returnNode.appendChild(body.firstChild);
+          }
+        } else {
+          returnNode = body;
+        }
+
+        if (RETURN_DOM_IMPORT) {
+          /*
+            AdoptNode() is not used because internal state is not reset
+            (e.g. the past names map of a HTMLFormElement), this is safe
+            in theory but we would rather not risk another attack vector.
+            The state that is cloned by importNode() is explicitly defined
+            by the specs.
+          */
+          returnNode = importNode.call(originalDocument, returnNode, true);
+        }
+
+        return returnNode;
+      }
+
+      var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+
+      /* Sanitize final string template-safe */
+      if (SAFE_FOR_TEMPLATES) {
+        serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$$1, ' ');
+        serializedHTML = stringReplace(serializedHTML, ERB_EXPR$$1, ' ');
+      }
+
+      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+    };
+
+    /**
+     * Public method to set the configuration once
+     * setConfig
+     *
+     * @param {Object} cfg configuration object
+     */
+    DOMPurify.setConfig = function (cfg) {
+      _parseConfig(cfg);
+      SET_CONFIG = true;
+    };
+
+    /**
+     * Public method to remove the configuration
+     * clearConfig
+     *
+     */
+    DOMPurify.clearConfig = function () {
+      CONFIG = null;
+      SET_CONFIG = false;
+    };
+
+    /**
+     * Public method to check if an attribute value is valid.
+     * Uses last set config, if any. Otherwise, uses config defaults.
+     * isValidAttribute
+     *
+     * @param  {string} tag Tag name of containing element.
+     * @param  {string} attr Attribute name.
+     * @param  {string} value Attribute value.
+     * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.
+     */
+    DOMPurify.isValidAttribute = function (tag, attr, value) {
+      /* Initialize shared config vars if necessary. */
+      if (!CONFIG) {
+        _parseConfig({});
+      }
+
+      var lcTag = transformCaseFunc(tag);
+      var lcName = transformCaseFunc(attr);
+      return _isValidAttribute(lcTag, lcName, value);
+    };
+
+    /**
+     * AddHook
+     * Public method to add DOMPurify hooks
+     *
+     * @param {String} entryPoint entry point for the hook to add
+     * @param {Function} hookFunction function to execute
+     */
+    DOMPurify.addHook = function (entryPoint, hookFunction) {
+      if (typeof hookFunction !== 'function') {
+        return;
+      }
+
+      hooks[entryPoint] = hooks[entryPoint] || [];
+      arrayPush(hooks[entryPoint], hookFunction);
+    };
+
+    /**
+     * RemoveHook
+     * Public method to remove a DOMPurify hook at a given entryPoint
+     * (pops it from the stack of hooks if more are present)
+     *
+     * @param {String} entryPoint entry point for the hook to remove
+     */
+    DOMPurify.removeHook = function (entryPoint) {
+      if (hooks[entryPoint]) {
+        arrayPop(hooks[entryPoint]);
+      }
+    };
+
+    /**
+     * RemoveHooks
+     * Public method to remove all DOMPurify hooks at a given entryPoint
+     *
+     * @param  {String} entryPoint entry point for the hooks to remove
+     */
+    DOMPurify.removeHooks = function (entryPoint) {
+      if (hooks[entryPoint]) {
+        hooks[entryPoint] = [];
+      }
+    };
+
+    /**
+     * RemoveAllHooks
+     * Public method to remove all DOMPurify hooks
+     *
+     */
+    DOMPurify.removeAllHooks = function () {
+      hooks = {};
+    };
+
+    return DOMPurify;
+  }
+
+  var purify = createDOMPurify();
+
+  return purify;
+
+}));
+
+
+},{}],290:[function(require,module,exports){
 /* jshint node: true */
 'use strict';
 
@@ -45814,7 +47214,7 @@ var freeice = function(opts) {
 };
 
 module.exports = freeice;
-},{"./stun.json":290,"./turn.json":291,"normalice":299}],290:[function(require,module,exports){
+},{"./stun.json":291,"./turn.json":292,"normalice":300}],291:[function(require,module,exports){
 module.exports=[
   "stun.l.google.com:19302",
   "stun1.l.google.com:19302",
@@ -45831,10 +47231,10 @@ module.exports=[
   "stun.voxgratia.org"
 ]
 
-},{}],291:[function(require,module,exports){
+},{}],292:[function(require,module,exports){
 module.exports=[]
 
-},{}],292:[function(require,module,exports){
+},{}],293:[function(require,module,exports){
 var WildEmitter = require('wildemitter');
 
 function getMaxVolume (analyser, fftBins) {
@@ -45979,9 +47379,9 @@ module.exports = function(stream, options) {
   return harker;
 }
 
-},{"wildemitter":328}],293:[function(require,module,exports){
+},{"wildemitter":329}],294:[function(require,module,exports){
 arguments[4][132][0].apply(exports,arguments)
-},{"dup":132}],294:[function(require,module,exports){
+},{"dup":132}],295:[function(require,module,exports){
 (function (global){(function (){
 // https://github.com/maxogden/websocket-stream/blob/48dc3ddf943e5ada668c31ccd94e9186f02fafbd/ws-fallback.js
 
@@ -46002,10 +47402,10 @@ if (typeof WebSocket !== 'undefined') {
 module.exports = ws
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{}],295:[function(require,module,exports){
+},{}],296:[function(require,module,exports){
 // Does nothing at all.
 
-},{}],296:[function(require,module,exports){
+},{}],297:[function(require,module,exports){
 /*
  * (C) Copyright 2014-2015 Kurento (http://kurento.org/)
  *
@@ -46926,7 +48326,7 @@ exports.WebRtcPeerSendonly = WebRtcPeerSendonly
 exports.WebRtcPeerSendrecv = WebRtcPeerSendrecv
 exports.hark = harkUtils
 
-},{"events":100,"freeice":289,"hark":292,"inherits":293,"kurento-browser-extensions":295,"merge":298,"sdp-translator":308,"ua-parser-js":313,"uuid/v4":316}],297:[function(require,module,exports){
+},{"events":100,"freeice":290,"hark":293,"inherits":294,"kurento-browser-extensions":296,"merge":299,"sdp-translator":309,"ua-parser-js":314,"uuid/v4":317}],298:[function(require,module,exports){
 /*
  * (C) Copyright 2014 Kurento (http://kurento.org/)
  *
@@ -46958,7 +48358,7 @@ var WebRtcPeer = require('./WebRtcPeer');
 
 exports.WebRtcPeer = WebRtcPeer;
 
-},{"./WebRtcPeer":296}],298:[function(require,module,exports){
+},{"./WebRtcPeer":297}],299:[function(require,module,exports){
 /*!
  * @name JavaScript/NodeJS Merge v1.2.1
  * @author yeikos
@@ -47136,7 +48536,7 @@ exports.WebRtcPeer = WebRtcPeer;
 	}
 
 })(typeof module === 'object' && module && typeof module.exports === 'object' && module.exports);
-},{}],299:[function(require,module,exports){
+},{}],300:[function(require,module,exports){
 /**
   # normalice
 
@@ -47198,7 +48598,7 @@ module.exports = function(input) {
   return output;
 };
 
-},{}],300:[function(require,module,exports){
+},{}],301:[function(require,module,exports){
 (function () {
     /*
      * Async module to handle async messaging
@@ -47911,7 +49311,7 @@ module.exports = function(input) {
     }
 })();
 
-},{"../utility/utility.js":302,"./socket.js":301}],301:[function(require,module,exports){
+},{"../utility/utility.js":303,"./socket.js":302}],302:[function(require,module,exports){
 (function() {
   /*
    * Socket Module to connect and handle Socket functionalities
@@ -48132,7 +49532,7 @@ module.exports = function(input) {
 
 })();
 
-},{"isomorphic-ws":294}],302:[function(require,module,exports){
+},{"isomorphic-ws":295}],303:[function(require,module,exports){
 (function (global){(function (){
 (function() {
   /**
@@ -48360,7 +49760,7 @@ module.exports = function(input) {
 })();
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{}],303:[function(require,module,exports){
+},{}],304:[function(require,module,exports){
 var grammar = module.exports = {
   v: [{
       name: 'version',
@@ -48619,7 +50019,7 @@ Object.keys(grammar).forEach(function (key) {
   });
 });
 
-},{}],304:[function(require,module,exports){
+},{}],305:[function(require,module,exports){
 var parser = require('./parser');
 var writer = require('./writer');
 
@@ -48629,7 +50029,7 @@ exports.parseFmtpConfig = parser.parseFmtpConfig;
 exports.parsePayloads = parser.parsePayloads;
 exports.parseRemoteCandidates = parser.parseRemoteCandidates;
 
-},{"./parser":305,"./writer":306}],305:[function(require,module,exports){
+},{"./parser":306,"./writer":307}],306:[function(require,module,exports){
 var toIntIfInt = function (v) {
   return String(Number(v)) === v ? Number(v) : v;
 };
@@ -48724,7 +50124,7 @@ exports.parseRemoteCandidates = function (str) {
   return candidates;
 };
 
-},{"./grammar":303}],306:[function(require,module,exports){
+},{"./grammar":304}],307:[function(require,module,exports){
 var grammar = require('./grammar');
 
 // customized util.format - discards excess arguments and can void middle ones
@@ -48840,7 +50240,7 @@ module.exports = function (session, opts) {
   return sdp.join('\r\n') + '\r\n';
 };
 
-},{"./grammar":303}],307:[function(require,module,exports){
+},{"./grammar":304}],308:[function(require,module,exports){
 /* Copyright @ 2015 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -48881,7 +50281,7 @@ module.exports = function arrayEquals(array) {
 };
 
 
-},{}],308:[function(require,module,exports){
+},{}],309:[function(require,module,exports){
 /* Copyright @ 2015 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -48899,7 +50299,7 @@ module.exports = function arrayEquals(array) {
 
 exports.Interop = require('./interop');
 
-},{"./interop":309}],309:[function(require,module,exports){
+},{"./interop":310}],310:[function(require,module,exports){
 /* Copyright @ 2015 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -49784,7 +51184,7 @@ Interop.prototype.toUnifiedPlan = function(desc) {
     //#endregion
 };
 
-},{"./array-equals":307,"./transform":310}],310:[function(require,module,exports){
+},{"./array-equals":308,"./transform":311}],311:[function(require,module,exports){
 /* Copyright @ 2015 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -49898,7 +51298,7 @@ exports.parse = function(sdp) {
 };
 
 
-},{"sdp-transform":304}],311:[function(require,module,exports){
+},{"sdp-transform":305}],312:[function(require,module,exports){
 /* eslint-env node */
 'use strict';
 
@@ -50659,7 +52059,7 @@ SDPUtils.isValidSDP = function (blob) {
 if ((typeof module === 'undefined' ? 'undefined' : _typeof(module)) === 'object') {
   module.exports = SDPUtils;
 }
-},{}],312:[function(require,module,exports){
+},{}],313:[function(require,module,exports){
 (function (global){(function (){
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -50947,7 +52347,7 @@ var __createBinding;
 });
 
 }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{}],313:[function(require,module,exports){
+},{}],314:[function(require,module,exports){
 /*!
  * UAParser.js v0.7.24
  * Lightweight JavaScript-based User-Agent string parser
@@ -51886,7 +53286,7 @@ var __createBinding;
 
 })(typeof window === 'object' ? window : this);
 
-},{}],314:[function(require,module,exports){
+},{}],315:[function(require,module,exports){
 /**
  * Convert array of 16 byte values to UUID string format of the form:
  * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
@@ -51914,7 +53314,7 @@ function bytesToUuid(buf, offset) {
 
 module.exports = bytesToUuid;
 
-},{}],315:[function(require,module,exports){
+},{}],316:[function(require,module,exports){
 // Unique ID creation requires a high quality random # generator.  In the
 // browser this is a little complicated due to unknown quality of Math.random()
 // and inconsistent support for the `crypto` API.  We do the best we can via
@@ -51950,7 +53350,7 @@ if (getRandomValues) {
   };
 }
 
-},{}],316:[function(require,module,exports){
+},{}],317:[function(require,module,exports){
 var rng = require('./lib/rng');
 var bytesToUuid = require('./lib/bytesToUuid');
 
@@ -51981,7 +53381,7 @@ function v4(options, buf, offset) {
 
 module.exports = v4;
 
-},{"./lib/bytesToUuid":314,"./lib/rng":315}],317:[function(require,module,exports){
+},{"./lib/bytesToUuid":315,"./lib/rng":316}],318:[function(require,module,exports){
 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
@@ -52002,7 +53402,7 @@ var _adapter_factory = require('./adapter_factory.js');
 var adapter = (0, _adapter_factory.adapterFactory)({ window: typeof window === 'undefined' ? undefined : window });
 exports.default = adapter;
 
-},{"./adapter_factory.js":318}],318:[function(require,module,exports){
+},{"./adapter_factory.js":319}],319:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -52167,7 +53567,7 @@ function adapterFactory() {
 
 // Browser shims.
 
-},{"./chrome/chrome_shim":319,"./common_shim":322,"./firefox/firefox_shim":323,"./safari/safari_shim":326,"./utils":327,"sdp":311}],319:[function(require,module,exports){
+},{"./chrome/chrome_shim":320,"./common_shim":323,"./firefox/firefox_shim":324,"./safari/safari_shim":327,"./utils":328,"sdp":312}],320:[function(require,module,exports){
 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
@@ -52916,7 +54316,7 @@ function fixNegotiationNeeded(window, browserDetails) {
   });
 }
 
-},{"../utils.js":327,"./getdisplaymedia":320,"./getusermedia":321}],320:[function(require,module,exports){
+},{"../utils.js":328,"./getdisplaymedia":321,"./getusermedia":322}],321:[function(require,module,exports){
 /*
  *  Copyright (c) 2018 The adapter.js project authors. All Rights Reserved.
  *
@@ -52967,7 +54367,7 @@ function shimGetDisplayMedia(window, getSourceId) {
   };
 }
 
-},{}],321:[function(require,module,exports){
+},{}],322:[function(require,module,exports){
 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
@@ -53172,7 +54572,7 @@ function shimGetUserMedia(window, browserDetails) {
   }
 }
 
-},{"../utils.js":327}],322:[function(require,module,exports){
+},{"../utils.js":328}],323:[function(require,module,exports){
 /*
  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
  *
@@ -53560,7 +54960,7 @@ function shimAddIceCandidateNullOrEmpty(window, browserDetails) {
   };
 }
 
-},{"./utils":327,"sdp":311}],323:[function(require,module,exports){
+},{"./utils":328,"sdp":312}],324:[function(require,module,exports){
 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
@@ -53895,7 +55295,7 @@ function shimCreateAnswer(window) {
   };
 }
 
-},{"../utils":327,"./getdisplaymedia":324,"./getusermedia":325}],324:[function(require,module,exports){
+},{"../utils":328,"./getdisplaymedia":325,"./getusermedia":326}],325:[function(require,module,exports){
 /*
  *  Copyright (c) 2018 The adapter.js project authors. All Rights Reserved.
  *
@@ -53934,7 +55334,7 @@ function shimGetDisplayMedia(window, preferredMediaSource) {
   };
 }
 
-},{}],325:[function(require,module,exports){
+},{}],326:[function(require,module,exports){
 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
@@ -54011,7 +55411,7 @@ function shimGetUserMedia(window, browserDetails) {
   }
 }
 
-},{"../utils":327}],326:[function(require,module,exports){
+},{"../utils":328}],327:[function(require,module,exports){
 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
@@ -54380,7 +55780,7 @@ function shimAudioContext(window) {
   window.AudioContext = window.webkitAudioContext;
 }
 
-},{"../utils":327}],327:[function(require,module,exports){
+},{"../utils":328}],328:[function(require,module,exports){
 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
@@ -54651,7 +56051,7 @@ function filterStats(result, track, outbound) {
   return filteredResult;
 }
 
-},{}],328:[function(require,module,exports){
+},{}],329:[function(require,module,exports){
 /*
 WildEmitter.js is a slim little event emitter by @henrikjoreteg largely based
 on @visionmedia's Emitter from UI Kit.
@@ -54808,7 +56208,7 @@ WildEmitter.mixin = function (constructor) {
 
 WildEmitter.mixin(WildEmitter);
 
-},{}],329:[function(require,module,exports){
+},{}],330:[function(require,module,exports){
 (function () {
     /**
      * Global Variables
@@ -54828,6 +56228,7 @@ WildEmitter.mixin(WildEmitter);
 
 
         var Utility = params.Utility,
+            currentModuleInstance = this,
             Sentry = params.Sentry,
             asyncClient = params.asyncClient,
             chatEvents = params.chatEvents,
@@ -54940,6 +56341,7 @@ WildEmitter.mixin(WildEmitter);
                 START_SCREEN_SHARE: 123,
                 END_SCREEN_SHARE: 124,
                 DELETE_FROM_CALL_HISTORY: 125,
+                DESTINATED_RECORD_CALL: 126,
                 MUTUAL_GROUPS: 130,
                 CREATE_TAG: 140,
                 EDIT_TAG: 141,
@@ -54948,6 +56350,7 @@ WildEmitter.mixin(WildEmitter);
                 REMOVE_TAG_PARTICIPANT: 144,
                 GET_TAG_LIST: 145,
                 DELETE_MESSAGE_THREAD: 151,
+                EXPORT_CHAT: 152,
                 ERROR: 999
             },
             inviteeVOidTypes = {
@@ -54999,20 +56402,25 @@ WildEmitter.mixin(WildEmitter);
             currentCallId = null,
             shouldReconnectCallTimeout = null,
             callTopics = {},
+            screenShareState = {
+                started: false,
+                imOwner: false
+            },
             callClientType = {
                 WEB: 1,
                 ANDROID: 2,
                 DESKTOP: 3
             },
             webpeers = {},
+            callUsers = {},
             webpeersMetadata = {},
             callRequestController = {
                 callRequestReceived: false,
                 callEstablishedInMySide: false,
                 iCanAcceptTheCall: function () {
                     return callRequestController.callRequestReceived && callRequestController.callEstablishedInMySide;
-
-                }
+                },
+                cameraPaused: true
             },
             uiRemoteMedias = {},
             callStopQueue = {
@@ -55246,7 +56654,7 @@ WildEmitter.mixin(WildEmitter);
             },
 
             endCall = function (params, callback) {
-                consoleLogging && console.log('endCall called...');
+                consoleLogging && console.log('[SDK][endCall] called...');
 
                 var endCallData = {
                     chatMessageVOType: chatMessageVOTypes.END_CALL_REQUEST,
@@ -55285,6 +56693,7 @@ WildEmitter.mixin(WildEmitter);
                     }
                 });
             },
+
             /*
              * Call Functionalities
              */
@@ -55292,25 +56701,36 @@ WildEmitter.mixin(WildEmitter);
                 if (callDivId) {
                     var callParentDiv,
                         callVideo = (typeof params.video === 'boolean') ? params.video : true,
-                        callMute = (typeof params.mute === 'boolean') ? params.mute : false,
-                        sendingTopic = params.sendingTopic,
-                        receiveTopic = params.receiveTopic;
+                        callMute = (typeof params.mute === 'boolean') ? params.mute : false;
+                        //sendingTopic = params.sendingTopic,
+                        //receiveTopic = params.receiveTopic;
+
+                    if(params.clientsList && params.clientsList.length) {
+                        for(var i in params.clientsList) {
+                            callStateController.setupCallParticipant(params.clientsList[i]);
+                            //callStateController.callUsers.push(params.clientsList[i]);
+                        }
+                    }
+
+                    callStateController.setupScreenSharingObject(params.screenShare);
 
-                    callTopics['sendVideoTopic'] = 'Vi-' + sendingTopic;
+                    /*callTopics['sendVideoTopic'] = 'Vi-' + sendingTopic;
                     callTopics['sendAudioTopic'] = 'Vo-' + sendingTopic;
+                    callTopics['screenShare'] = params.screenShare;
                     //callTopics['receiveVideoTopic'] = 'Vi-' + receiveTopic;
                     //callTopics['receiveAudioTopic'] = 'Vo-' + receiveTopic;
                     callTopics['receive'] = [];
                     callTopics['receive'].push({
                         "VideoTopic": 'Vi-' + receiveTopic,
                         "AudioTopic": 'Vo-' + receiveTopic
-                    });
+                    });*/
 
-                    webpeersMetadata[callTopics['sendVideoTopic']] = {
+                    /*webpeersMetadata[callTopics['sendVideoTopic']] = {
                         interval: null,
                         receivedSdpAnswer: false,
                         connectionQualityInterval: null,
                         poorConnectionCount: 0,
+                        poorConnectionResolvedCount: 0,
                         isConnectionPoor: false
                     };
                     webpeersMetadata[callTopics['sendAudioTopic']] = {
@@ -55318,6 +56738,15 @@ WildEmitter.mixin(WildEmitter);
                         receivedSdpAnswer: false,
                         connectionQualityInterval: null,
                         poorConnectionCount: 0,
+                        poorConnectionResolvedCount: 0,
+                        isConnectionPoor: false
+                    };
+                    webpeersMetadata[callTopics['screenShare']] = {
+                        interval: null,
+                        receivedSdpAnswer: false,
+                        connectionQualityInterval: null,
+                        poorConnectionCount: 0,
+                        poorConnectionResolvedCount: 0,
                         isConnectionPoor: false
                     };
 
@@ -55330,11 +56759,11 @@ WildEmitter.mixin(WildEmitter);
                             interval: null,
                             receivedSdpAnswer: false
                         };
-                    }
+                    }*/
 
-                    callParentDiv = document.getElementById(callDivId);
+                    //callParentDiv = document.getElementById(callDivId);
 
-                    // Local Video Tag
+                    /*// Local Video Tag
                     if (callVideo && !uiRemoteMedias[callTopics['sendVideoTopic']]) {
                         uiRemoteMedias[callTopics['sendVideoTopic']] = document.createElement('video');
                         var el = uiRemoteMedias[callTopics['sendVideoTopic']];
@@ -55380,10 +56809,11 @@ WildEmitter.mixin(WildEmitter);
                             callMute && el.setAttribute('muted', '');
                             el.setAttribute('controls', '');
                         }
-                    }
+                    }*/
 
-                    var uiRemoteElements = [];
-                    for(var i in callTopics['receive']) {
+                    callback && callback(generateCallUIList());
+
+                    /*for(var i in callTopics['receive']) {
                         uiRemoteElements.push(uiRemoteMedias[callTopics['receive'][i]['AudioTopic']])
                         callVideo && uiRemoteElements.push(uiRemoteMedias[callTopics['receive'][i]['VideoTopic']])
                     }
@@ -55404,18 +56834,19 @@ WildEmitter.mixin(WildEmitter);
                             'uiLocalVideo': uiRemoteMedias[callTopics['sendVideoTopic']],
                             'uiLocalAudio': uiRemoteMedias[callTopics['sendAudioTopic']],
                             uiRemoteElements: uiRemoteElements
-                            /*                            'uiRemoteVideo': uiRemoteMedias[callTopics['receiveVideoTopic']],
-                                                        'uiRemoteAudio': uiRemoteMedias[callTopics['receiveAudioTopic']]*/
+                            /!*                            'uiRemoteVideo': uiRemoteMedias[callTopics['receiveVideoTopic']],
+                                                        'uiRemoteAudio': uiRemoteMedias[callTopics['receiveAudioTopic']]*!/
                         });
                     } else {
                         callback && callback({
                             'uiLocalVideo': uiRemoteMedias[callTopics['sendVideoTopic']],
                             'uiLocalAudio': uiRemoteMedias[callTopics['sendAudioTopic']],
                             uiRemoteElements: uiRemoteElements
-                            /*'uiRemoteVideo': uiRemoteMedias[callTopics['receiveVideoTopic']],
-                            'uiRemoteAudio': uiRemoteMedias[callTopics['receiveAudioTopic']]*/
+                            /!*'uiRemoteVideo': uiRemoteMedias[callTopics['receiveVideoTopic']],
+                            'uiRemoteAudio': uiRemoteMedias[callTopics['receiveAudioTopic']]*!/
                         });
-                    }
+                    }*/
+
 
                     callStateController.createSessionInChat(Object.assign(params, {
                         callVideo: callVideo,
@@ -55440,34 +56871,32 @@ WildEmitter.mixin(WildEmitter);
                 }
             },
 
-
-            /*handleCallSocketOpen = function (params) {
-                currentCallParams = params;
-
-                sendCallMessage({
-                    id: 'CREATE_SESSION',
-                    brokerAddress: params.brokerAddress,
-                    turnAddress: params.turnAddress.split(',')[0]
-                }, function (res) {
-                    if (res.done === 'TRUE') {
-                        callStopQueue.callStarted = true;
-                        generateAndSendSdpOffers(params, [callTopics['sendVideoTopic'], callTopics['receiveVideoTopic'], callTopics['sendAudioTopic'], callTopics['receiveAudioTopic']]);
-                    } else if (res.done === 'SKIP') {
-                        callStopQueue.callStarted = true;
-                        generateAndSendSdpOffers(params, [callTopics['sendVideoTopic'], callTopics['receiveVideoTopic'], callTopics['sendAudioTopic'], callTopics['receiveAudioTopic']]);
-                    } else {
-                        consoleLogging && console.log('CREATE_SESSION faced a problem', res);
-                        endCall({
-                            callId: currentCallId
-                        });
+            generateCallUIList = function () {
+                var me = chatMessaging.userInfo.Id;
+                var callUIElements = {};
+                for(var i in callUsers) {
+                    callUIElements[i] = {
+                        container: callUsers[i].htmlElements.container,
+                        video: callUsers[i].htmlElements[callUsers[i].videoTopicName],
+                        audio: callUsers[i].htmlElements[callUsers[i].audioTopicName]
                     }
-                });
-            },*/
+
+/*                    callUIElements[i].container = callUsers[i].htmlElements.container;
+                    callUIElements[i].video = callUsers[i].htmlElements[callUsers[i].videoTopicName];
+                    callUIElements[i].audio = callUsers[i].htmlElements[callUsers[i].audioTopicName];
+                    */
+                    //callUIElements[i] = callUsers[i].htmlElements;
+                }
+                return {
+                    uiElements: callUIElements,
+                };
+            },
 
             callStateController = {
                 createSessionInChat: function (params) {
                     currentCallParams = params;
                     var callController = this;
+                    consoleLogging && console.log("createSessionInChat:inside", params);
                     sendCallMessage({
                         id: 'CREATE_SESSION',
                         brokerAddress: params.brokerAddress,
@@ -55494,18 +56923,144 @@ WildEmitter.mixin(WildEmitter);
                  */
                 startCall: function (params) {
                     var callController = this;
-                    if (params.callVideo) {
-                        this.startParticipantVideo(callTopics['receive'][0]['VideoTopic'], 'receive');
-                        setTimeout(function (){
-                            callController.startMyVideo();
-                        }, 2000);
+                    for(var i in callUsers) {
+                        if(i === 'screenShare')
+                            continue;
+
+                        if(callUsers[i].video) {
+                            callController.startParticipantVideo(i);
+                        }
+                        if(!callUsers[i].mute) {
+                            callController.startParticipantAudio(i);
+                        }
+                        /*if (params.callVideo) {
+                            callController.startParticipantVideo(i);
+                        }*/
+                        /*if(params.callAudio) {
+                            callController.startParticipantAudio(i);
+                        }*/
                     }
-                    if(params.callAudio) {
-                        this.startParticipantAudio(callTopics['receive'][0]['AudioTopic'], 'receive');
-                        setTimeout(function (){
-                            callController.startMyAudio();
-                        }, 2000)
+                },
+                setupCallParticipant: function (participant) {
+                    var user = participant;
+                    user.topicMetaData = {};
+                    user.peers = {};
+                    if(user.userId === chatMessaging.userInfo.id) {
+                        user.direction = 'send';
+                    } else {
+                        user.direction = 'receive';
                     }
+                    user.videoTopicName = 'Vi-' + user.topicSend;
+                    user.audioTopicName = 'Vo-' + user.topicSend;
+                    user.topicMetaData[user.videoTopicName] = {
+                        interval: null,
+                        receivedSdpAnswer: false,
+                        connectionQualityInterval: null,
+                        poorConnectionCount: 0,
+                        poorConnectionResolvedCount: 0,
+                        isConnectionPoor: false
+                    };
+                    user.topicMetaData[user.audioTopicName] = {
+                        interval: null,
+                        receivedSdpAnswer: false,
+                        connectionQualityInterval: null,
+                        poorConnectionCount: 0,
+                        poorConnectionResolvedCount: 0,
+                        isConnectionPoor: false
+                    };
+                    callUsers[user.userId] = user;
+                    this.appendUserToCallDiv(user.userId, this.generateHTMLElements(user.userId));
+                },
+                setupScreenSharingObject: function (topic) {
+                    var obj = {
+                        video: true,
+                    };
+                    obj.topicMetaData = {};
+                    obj.peers = {};
+                    if(screenShareState.imOwner) {
+                        obj.direction = 'send';
+                    } else {
+                        obj.direction = 'receive'
+                    }
+                    obj.videoTopicName = topic;
+                    obj.topicMetaData[obj.videoTopicName] = {
+                        interval: null,
+                        receivedSdpAnswer: false,
+                        connectionQualityInterval: null,
+                        poorConnectionCount: 0,
+                        poorConnectionResolvedCount: 0,
+                        isConnectionPoor: false
+                    };
+                    callUsers['screenShare'] = obj;
+                    this.generateHTMLElements('screenShare')
+                },
+                appendUserToCallDiv: function (userId) {
+                    if(!callDivId) {
+                        consoleLogging && console.log('No Call DIV has been declared!');
+                        return;
+                    }
+                    var user = callUsers[userId]
+                    var callParentDiv = document.getElementById(callDivId);
+                    if(user.video) {
+                        console.log("appendUserToCallDiv1", user, document.getElementById("callParticipantWrapper-" + userId), document.getElementById("uiRemoteVideo-" + user.videoTopicName))
+                        if(!document.getElementById("callParticipantWrapper-" + userId)) {
+                            if (!document.getElementById("uiRemoteVideo-" + user.videoTopicName)) {
+                                user.htmlElements.container.appendChild(user.htmlElements[user.videoTopicName])
+                            }
+                        }
+                        else {
+                            document.getElementById("callParticipantWrapper-" + userId).append(user.htmlElements[user.videoTopicName])
+                        }
+                    }
+                    if(typeof user.mute !== "undefined" && !user.mute){
+                        if(!document.getElementById("callParticipantWrapper-" + userId)) {
+                            if(!document.getElementById("uiRemoteAudio-" + user.videoTopicName)) {
+                                user.htmlElements.container.appendChild(user.htmlElements[user.audioTopicName])
+                            }
+                        } else {
+                            document.getElementById("callParticipantWrapper-" + userId).append(user.htmlElements[user.audioTopicName])
+                        }
+                    }
+
+                    if(!document.getElementById("callParticipantWrapper-" + userId))
+                        callParentDiv.appendChild(user.htmlElements.container);
+                },
+                generateHTMLElements: function (userId) {
+                    var user = callUsers[userId]
+                    if(!user.htmlElements) {
+                        user.htmlElements = {
+                            container: document.createElement('div')
+                        };
+                        var el = user.htmlElements.container;
+                        el.setAttribute('id', 'callParticipantWrapper-' + userId);
+                        el.classList.add('participant');
+                        el.classList.add('wrapper');
+                        el.classList.add('user-' + userId);
+                        el.classList.add((userId === chatMessaging.userInfo.id ? 'local' : 'remote'));
+                    }
+
+                    if (user.video && !user.htmlElements[user.videoTopicName]) {
+                        user.htmlElements[user.videoTopicName] = document.createElement('video');
+                        var el = user.htmlElements[user.videoTopicName];
+                        el.setAttribute('id', 'uiRemoteVideo-' + user.videoTopicName);
+                        el.setAttribute('class', callVideoTagClassName);
+                        el.setAttribute('playsinline', '');
+                        el.setAttribute('muted', '');
+                        el.setAttribute('width', callVideoMinWidth + 'px');
+                        el.setAttribute('height', callVideoMinHeight + 'px');
+                    }
+
+                    if (typeof user.mute !== 'undefined' && !user.mute && !user.htmlElements[user.audioTopicName]) {
+                        user.htmlElements[user.audioTopicName] = document.createElement('audio');
+                        var el = user.htmlElements[user.audioTopicName];
+                        el.setAttribute('id', 'uiRemoteAudio-' + user.audioTopicName);
+                        el.setAttribute('class', callAudioTagClassName);
+                        el.setAttribute('autoplay', '');
+                        el.setAttribute('muted', '');
+                        el.setAttribute('controls', '');
+                    }
+
+                    return user.htmlElements;
                 },
                 /**
                  * When call started we can add participants
@@ -55531,77 +57086,88 @@ WildEmitter.mixin(WildEmitter);
                         return;
                     }
                 },
-                stopMyAudio: function () {
-                    this.removeTopic(callTopics['sendAudioTopic']);
-                },
-                startMyAudio: function () {
-                    this.createTopic(callTopics['sendAudioTopic'], 'audio', 'send');
+                stopParticipantAudio: function (userId) {
+                    this.removeTopic(userId, callUsers[userId].peers[userId].audioTopicName);
                 },
-                stopParticipantAudio: function (topic) {
-                    this.removeTopic(topic);
+                startParticipantAudio: function (userId) {
+                    this.createTopic(userId, callUsers[userId].audioTopicName, 'audio', callUsers[userId].direction);
                 },
-                startParticipantAudio: function (topic) {
-                    this.createTopic(topic, 'audio', 'receive');
+                stopParticipantVideo: function (userId) {
+                    this.removeTopic(userId, callUsers[userId].peers[userId].videoTopicName);
                 },
-                stopMyVideo: function () {
-                    this.removeTopic(callTopics['sendVideoTopic']);
+                startParticipantVideo: function (userId) {
+                    this.createTopic(userId, callUsers[userId].videoTopicName, 'video', callUsers[userId].direction);
                 },
-                startMyVideo: function () {
-                    this.createTopic(callTopics['sendVideoTopic'], 'video','send');
-                },
-                stopParticipantVideo: function (topic) {
-                    this.removeTopic(topic);
-                },
-                startParticipantVideo: function (topic) {
-                    this.createTopic(topic, 'video', 'receive');
-                },
-                createTopic: function (topic, mediaType, direction) {
-                    var options = this.getSdpOfferOptions(topic, mediaType, direction);
-                    this.generateTopicPeer(topic, mediaType, direction, options);
-                },
-                removeTopic: function (topic) {
-                    for(var i in webpeers) {
-                        if(i === topic) {
-                            webpeers[i].dispose();
-                            webpeers[i] = null;
-                        }
+                createTopic: function (userId, topic, mediaType, direction, shareScreen) {
+                    if(callUsers[userId] && callUsers[userId].peers[topic]) {
+                        return;
                     }
+                    shareScreen = typeof shareScreen !== 'undefined' ? shareScreen : false;
+                    this.getSdpOfferOptions(userId, topic, mediaType, direction, shareScreen).then(function (options){
+                        callStateController.generateTopicPeer(userId, topic, mediaType, direction, options);
+                    });
                 },
-                getSdpOfferOptions: function (topic, mediaType, direction) {
-                    var mediaConstraints = {audio: (mediaType === 'audio'), video: (mediaType === 'video')};
-                    if(direction === 'send') {
-                        mediaConstraints.video = {
-                            width: callVideoMinWidth,
-                            height: callVideoMinHeight,
-                            framerate: 15
-                        }
+                removeTopic: function (userId, topic) {
+                    if(callUsers[userId].peers[topic]) {
+                        this.removeConnectionQualityInterval(userId, topic);
+                        callUsers[userId].peers[topic].dispose();
+                        callUsers[userId].peers[topic] = null;
                     }
-                    var options = {
-                        mediaConstraints: mediaConstraints,
-                        iceTransportPolicy: 'relay',
-                        onicecandidate: (candidate) => {
-                            if (webpeersMetadata[topic].interval !== null) {
-                                clearInterval(webpeersMetadata[topic].interval);
+                },
+                getSdpOfferOptions: function (userId, topic, mediaType, direction, shareScreen) {
+                    return new Promise(function (resolve, reject) {
+                        var mediaConstraints = {audio: (mediaType === 'audio'), video: (mediaType === 'video')};
+
+                        if(direction === 'send' && mediaType === 'video') {
+                            mediaConstraints.video = {
+                                width: callVideoMinWidth,
+                                height: callVideoMinHeight,
+                                framerate: 15
                             }
-                            webpeersMetadata[topic].interval = setInterval(function () {
-                                if (webpeersMetadata[topic].sdpAnswerReceived === true) {
-                                    webpeersMetadata[topic].sdpAnswerReceived = false;
-                                    clearInterval(webpeersMetadata[topic].interval);
-                                    sendCallMessage({
-                                        id: 'ADD_ICE_CANDIDATE',
-                                        topic: topic,
-                                        candidateDto: candidate
-                                    })
+                        }
+
+                        var options = {
+                            mediaConstraints: mediaConstraints,
+                            iceTransportPolicy: 'relay',
+                            onicecandidate: (candidate) => {
+                                if (callUsers[userId].topicMetaData[topic].interval !== null) {
+                                    clearInterval(callUsers[userId].topicMetaData[topic].interval);
                                 }
-                            }, 500, {candidate: candidate});
-                        },
-                        configuration: {
-                            iceServers: this.getTurnServer(currentCallParams)
+                                callUsers[userId].topicMetaData[topic].interval = setInterval(function () {
+                                    if (callUsers[userId].topicMetaData[topic].sdpAnswerReceived === true) {
+                                        callUsers[userId].topicMetaData[topic].sdpAnswerReceived = false;
+                                        clearInterval(callUsers[userId].topicMetaData[topic].interval);
+                                        sendCallMessage({
+                                            id: 'ADD_ICE_CANDIDATE',
+                                            topic: topic,
+                                            candidateDto: candidate
+                                        })
+                                    }
+                                }, 500, {candidate: candidate});
+                            },
+                            configuration: {
+                                iceServers: callStateController.getTurnServer(currentCallParams)
+                            }
+                        };
+
+                        options[(direction === 'send' ? 'localVideo' : 'remoteVideo')] = callUsers[userId].htmlElements[topic];
+
+                        if(direction === 'send' && mediaType === 'video' && shareScreen) {
+                            navigator.mediaDevices.getDisplayMedia().then(function (result) {
+                                options.videoStream = result;
+                                options.sendSource = 'screen';
+                                // options[(direction === 'send' ? 'localVideo' : 'remoteVideo')] = uiRemoteMedias[topic];
+                                resolve(options);
+                            }).catch(function (error) {
+                                console.error("[SDK][navigator.mediaDevices.getDisplayMedia]", error);
+                                explainUserMediaError(error, 'video', 'screen');
+                                //resolve(options);
+                            });
+                        } else {
+                            resolve(options);
                         }
-                    };
-                    options[(direction === 'send' ? 'localVideo' : 'remoteVideo')] = uiRemoteMedias[topic];
-                    consoleLogging && console.log("getSdpOfferOptions:", "topic: ", topic, "mediaType: ", mediaType, "direction: ", direction, "options: ", options)
-                    return options;
+                        consoleLogging && console.log("[SDK][getSdpOfferOptions] ", "topic: ", topic, "mediaType: ", mediaType, "direction: ", direction, "options: ", options);
+                    });
                 },
                 getTurnServer: function (params) {
                     if (!!params.turnAddress && params.turnAddress.length > 0) {
@@ -55624,90 +57190,16 @@ WildEmitter.mixin(WildEmitter);
                         ];
                     }
                 },
-                watchRTCPeerConnection: function (topic, mediaType, direction) {
-                    console.log("set callback on webpeers: ", topic, mediaType, direction);
-
-                    var callController = this;
-                    webpeers[topic].peerConnection.onconnectionstatechange = function () {
-                        console.log("on connection state change, ", "peer: ", topic, "peerConnection.connectionState: ", webpeers[topic].peerConnection.connectionState);
-                        if (webpeers[topic].peerConnection.connectionState === 'disconnected') {
-                            console.log(topic, 'peerConnection.onconnectionstatechange: disconnected');
-
-                            callController.removeConnectionQualityInterval(topic);
-                        }
-
-                        if (webpeers[topic].peerConnection.connectionState === "failed") {
-                            chatEvents.fireEvent('callEvents', {
-                                type: 'CALL_STATUS',
-                                errorCode: 7000,
-                                errorMessage: `Call Peer (${topic}) has failed!`,
-                                errorInfo: webpeers[topic]
-                            });
-                            setTimeout(function () {
-                                if(chatMessaging.chatState) {
-                                    callController.shouldReconnectTopic(topic, mediaType, direction);
-                                }
-                            }, 7000);
-
-                            callController.removeConnectionQualityInterval(topic);
-                        }
-
-                        if(webpeers[topic].peerConnection.connectionState === 'connected') {
-                            if(mediaType === 'video' && direction === 'send') {
-                                webpeersMetadata[topic]['connectionQualityInterval'] = setInterval(function() {
-                                    callController.checkConnectionQuality(topic, mediaType, direction)
-                                }, 1000);
-                            }
-                        }
-                    }
-
-                    webpeers[topic].peerConnection.oniceconnectionstatechange = function () {
-                        console.log("on ice connection state change:  ", topic, webpeers[topic].peerConnection.iceConnectionState);
-                        if (webpeers[topic].peerConnection.iceConnectionState === 'disconnected') {
-                            console.log(topic, 'peerConnection.oniceconnectionstatechange disconnected');
-                            chatEvents.fireEvent('callEvents', {
-                                type: 'CALL_STATUS',
-                                errorCode: 7000,
-                                errorMessage: `Call Peer (${topic}) is disconnected!`,
-                                errorInfo: webpeers[topic]
-                            });
-
-                            console.log('Internet connection failed, Reconnect your call, topic:', topic);
-                        }
-
-                        if (webpeers[topic].peerConnection.iceConnectionState === "failed") {
-                            chatEvents.fireEvent('callEvents', {
-                                type: 'CALL_STATUS',
-                                errorCode: 7000,
-                                errorMessage: `Call Peer (${topic}) has failed!`,
-                                errorInfo: webpeers[topic]
-                            });
-                            if(chatMessaging.chatState) {
-                                callController.shouldReconnectTopic(topic, mediaType, direction);
-                            } else {
-                                setTimeout(function () {
-                                    if(chatMessaging.chatState) {
-                                        callController.shouldReconnectTopic(topic, mediaType, direction);
-                                    }
-                                }, 7000);
-                            }
-                        }
-
-                        if (webpeers[topic].peerConnection.iceConnectionState === "connected") {
-                            callRequestController.callEstablishedInMySide = true;
-                            chatEvents.fireEvent('callEvents', {
-                                type: 'CALL_STATUS',
-                                errorCode: 7000,
-                                errorMessage: `Call Peer (${topic}) has connected!`,
-                                errorInfo: webpeers[topic]
-                            });
-                        }
+                checkConnectionQuality: function (userId, topic) {
+                    if(!callUsers[userId] || !callUsers[userId].peers[topic] || !callUsers[userId].peers[topic].peerConnection) {
+                        callStateController.removeConnectionQualityInterval(userId, topic);
+                        return;
                     }
-                },
-                checkConnectionQuality: function (topic) {
-                    webpeers[topic].peerConnection.getStats(null).then(stats => {
+                    callUsers[userId].peers[topic].peerConnection.getStats(null).then(stats => {
                         //console.log(' watchRTCPeerConnection:: window.setInterval then(stats:', stats)
                         //let statsOutput = "";
+                        var user = callUsers[userId],
+                            userMetadata = user.topicMetaData[topic]
 
                         stats.forEach(report => {
                             if(report && report.type && report.type === 'remote-inbound-rtp') {
@@ -55717,34 +57209,52 @@ WildEmitter.mixin(WildEmitter);
                                 // Now the statistics for this report; we intentially drop the ones we
                                 // sorted to the top above
                                 if(!report['roundTripTime'] || report['roundTripTime'] > 1) {
-                                    if(webpeersMetadata[topic].poorConnectionCount > 3 && !webpeersMetadata[topic].isConnectionPoor) {
+                                    if(userMetadata.poorConnectionCount === 10) {
+                                        chatEvents.fireEvent('callEvents', {
+                                            type: 'POOR_VIDEO_CONNECTION',
+                                            subType: 'LONG_TIME',
+                                            message: 'Poor connection for a long time',
+                                            metadata: {
+                                                elementId: "uiRemoteVideo-" + topic,
+                                                topic: topic
+                                            }
+                                        });
+                                    }
+                                    if(userMetadata.poorConnectionCount > 3 && !userMetadata.isConnectionPoor) {
                                         //alert('Poor connection detected...');
-                                        consoleLogging && console.log('Poor connection detected...');
+                                        consoleLogging && console.log('[SDK][checkConnectionQuality] Poor connection detected...');
                                         chatEvents.fireEvent('callEvents', {
                                             type: 'POOR_VIDEO_CONNECTION',
+                                            subType: 'SHORT_TIME',
                                             message: 'Poor connection detected',
+                                            metadata: {
+                                                elementId: "uiRemoteVideo-" + topic,
+                                                topic: topic,
+                                                userId: userId
+                                            }
+                                        });
+                                        userMetadata.isConnectionPoor = true;
+                                        userMetadata.poorConnectionCount = 0;
+                                        userMetadata.poorConnectionResolvedCount = 0;
+                                    } else {
+                                        callUsers[userId].topicMetaData[topic].poorConnectionCount++;
+                                    }
+                                } else if(report['roundTripTime'] || report['roundTripTime'] < 1) {
+                                    if(userMetadata.poorConnectionResolvedCount > 3 && userMetadata.isConnectionPoor) {
+                                        userMetadata.poorConnectionResolvedCount = 0;
+                                        userMetadata.poorConnectionCount = 0;
+                                        userMetadata.isConnectionPoor = false;
+                                        chatEvents.fireEvent('callEvents', {
+                                            type: 'POOR_VIDEO_CONNECTION_RESOLVED',
+                                            message: 'Poor connection resolved',
                                             metadata: {
                                                 elementId: "uiRemoteVideo-" + topic,
                                                 topic: topic
                                             }
                                         });
-                                        webpeersMetadata[topic].isConnectionPoor = true;
-                                        webpeersMetadata[topic].poorConnectionCount = 0;
                                     } else {
-                                        webpeersMetadata[topic].poorConnectionCount++;
+                                        userMetadata.poorConnectionResolvedCount++;
                                     }
-
-                                } else if((report['roundTripTime'] || report['roundTripTime'] < 1) && webpeersMetadata[topic].isConnectionPoor) {
-                                    webpeersMetadata[topic].poorConnectionCount = 0;
-                                    webpeersMetadata[topic].isConnectionPoor = false;
-                                    chatEvents.fireEvent('callEvents', {
-                                        type: 'POOR_VIDEO_CONNECTION_RESOLVED',
-                                        message: 'Poor connection resolved',
-                                        metadata: {
-                                            elementId: "uiRemoteVideo-" + topic,
-                                            topic: topic
-                                        }
-                                    });
                                 }
 
                                 /*Object.keys(report).forEach(function (statName) {
@@ -55758,72 +57268,35 @@ WildEmitter.mixin(WildEmitter);
                         //document.querySelector(".stats-box").innerHTML = statsOutput;
                     });
                 },
-                removeConnectionQualityInterval: function (topic) {
-                    //isConnectionPoor
-                    webpeersMetadata[topic]['poorConnectionCount'] = 0;
-                    clearInterval(webpeersMetadata[topic]['connectionQualityInterval']);
-                },
-                shouldReconnectTopic: function (topic, mediaType, direction) {
-                    var callController = this;
-                    if (currentCallParams && Object.keys(currentCallParams).length) {
-                        if (webpeers[topic].peerConnection.iceConnectionState != 'connected') {
-                            chatEvents.fireEvent('callEvents', {
-                                type: 'CALL_STATUS',
-                                errorCode: 7000,
-                                errorMessage: `Call Peer (${topic}) is not in connected state, Restarting call in progress ...!`,
-                                errorInfo: webpeers[topic]
-                            });
-
-                            sendCallMessage({
-                                id: 'STOP',
-                                topic: topic
-                            }, function (result) {
-                                if (result.done === 'TRUE') {
-                                    //handleCallSocketOpen(currentCallParams);
-                                    /*webpeers[topic].dispose();
-                                    webpeers[topic] = null;*/
-                                    callController.removeTopic(topic);
-                                    callController.createTopic(topic, mediaType, direction);
-                                    //generateAndSendSdpOffers(currentCallParams, [topicName]);
-                                } else if (result.done === 'SKIP') {
-                                    //handleCallSocketOpen(currentCallParams);
-                                    /*webpeers[topic].dispose();
-                                    webpeers[topic] = null;*/
-                                    callController.removeTopic(topic);
-                                    callController.createTopic(topic, mediaType, direction);
-                                    //generateAndSendSdpOffers(currentCallParams, [topicName]);
-                                } else {
-                                    consoleLogging && console.log('STOP topic faced a problem', result);
-                                    endCall({
-                                        callId: currentCallId
-                                    });
-                                    callStop();
-                                }
-                            });
-                        }
-                    }
-                },
-                generateTopicPeer: function (topic, mediaType, direction, options) {
+                generateTopicPeer: function (userId, topic, mediaType, direction, options) {
                     var WebRtcFunction = direction === 'send' ? 'WebRtcPeerSendonly' : 'WebRtcPeerRecvonly',
-                    callController = this;
+                        callController = this,
+                        user = callUsers[userId],
+                        topicElement = user.htmlElements[topic],
+                        topicMetaData = user.topicMetaData[topic];
 
-                    webpeers[topic] = new KurentoUtils.WebRtcPeer[WebRtcFunction](options, function (err) {
+                    callUsers[userId].peers[topic] = new KurentoUtils.WebRtcPeer[WebRtcFunction](options, function (err) {
                         if (err) {
-                            console.error("[start/webRtc " + direction + "  " + mediaType + " Peer] Error: " + explainUserMediaError(err, mediaType));
+                            console.error("[SDK][start/webRtc " + direction + "  " + mediaType + " Peer] Error: " + explainUserMediaError(err, mediaType));
                             return;
                         }
 
-                        callController.watchRTCPeerConnection(topic, mediaType, direction);
+                        callController.watchRTCPeerConnection(userId, topic, mediaType, direction);
 
-                        if(direction === 'send')
-                            startMedia(uiRemoteMedias[topic]);
+                        if(direction === 'send') {
+                            startMedia(topicElement);
+                            if(callRequestController.cameraPaused) {
+                                currentModuleInstance.pauseCamera();
+                            }
+                        }
 
-                        webpeers[topic].generateOffer((err, sdpOffer) => {
+                        callUsers[userId].peers[topic].generateOffer((err, sdpOffer) => {
                             if (err) {
-                                console.error("[start/WebRc " + direction + "  " + mediaType + " Peer/generateOffer] " + err);
+                                console.error("[SDK][start/WebRc " + direction + "  " + mediaType + " Peer/generateOffer] " + err);
                                 return;
                             }
 
+                            sdpOffer = callController.setMediaBitrates(sdpOffer);
                             sendCallMessage({
                                 id: (direction === 'send' ? 'SEND_SDP_OFFER' : 'RECIVE_SDP_OFFER'),
                                 sdpOffer: sdpOffer,
@@ -55834,456 +57307,331 @@ WildEmitter.mixin(WildEmitter);
                             });
                         });
                     });
-                }
-            },
-
-/*
-            shouldReconnectCall = function (topic) {
-                if (currentCallParams && Object.keys(currentCallParams).length) {
-                    if (webpeers[topic] && webpeers[topic].peerConnection.iceConnectionState != 'connected') {
-
-                        chatEvents.fireEvent('callEvents', {
-                            type: 'CALL_STATUS',
-                            errorCode: 7000,
-                            errorMessage: `Call Peer (${topic}) is not in connected state, Restarting call in progress ...!`,
-                            errorInfo: webpeers[topic]
-                        });
-
-                        sendCallMessage({
-                            id: 'STOP',
-                            topic: topic
-                        }, function (result) {
-                            if (result.done === 'TRUE') {
-                                //handleCallSocketOpen(currentCallParams);
-                                /!*webpeers[topic].dispose();
-                                webpeers[topic] = null;*!/
-                                generateAndSendSdpOffers(currentCallParams, [topic]);
-
-                            } else if (result.done === 'SKIP') {
-                                //handleCallSocketOpen(currentCallParams);
-                                /!*webpeers[topic].dispose();
-                                webpeers[topic] = null;*!/
-                                generateAndSendSdpOffers(currentCallParams, [topic]);
-                            } else {
-                                consoleLogging && console.log('STOP topic faced a problem', result);
-                                endCall({
-                                    callId: currentCallId
-                                });
-                                callStop();
-                            }
-                        });
-                    }
-                }
-            },
-
-            generateAndSendSdpOffers = function (params, topics) {
-                var turnServers = [];
+                },
+                watchRTCPeerConnection: function (userId, topic, mediaType, direction) {
+                    consoleLogging && console.log("[SDK][watchRTCPeerConnection] called with: ", userId, topic, mediaType, direction);
+                    var callController = this,
+                        user = callUsers[userId];
 
-                if (!!params.turnAddress && params.turnAddress.length > 0) {
-                    var serversTemp = params.turnAddress.split(',');
+                    consoleLogging && console.log("[SDK][watchRTCPeerConnection] called with: ", callUsers, user);
 
-                    turnServers = [
-                        //{"urls": "stun:" + serversTemp[0]},
-                        {
-                            "urls": "turn:" + serversTemp[0],
-                            "username": "mkhorrami",
-                            "credential": "mkh_123456"
+                    user.peers[topic].peerConnection.onconnectionstatechange = function () {
+                        if(!user || !user.peers || !user.peers[topic]) {
+                            return; //avoid log errors
                         }
-                    ];
-                } else {
-                    turnServers = [
-                        //{"urls": "stun:" + callTurnIp + ":3478"},
-                        {
-                            "urls": "turn:" + callTurnIp + ":3478",
-                            "username": "mkhorrami",
-                            "credential": "mkh_123456"
+                        consoleLogging && console.log("[SDK][peerConnection.onconnectionstatechange] ", "peer: ", topic, " peerConnection.connectionState: ", user.peers[topic].peerConnection.connectionState);
+                        if (user.peers[topic].peerConnection.connectionState === 'disconnected') {
+                            callController.removeConnectionQualityInterval(userId, topic);
                         }
-                    ];
-                }
 
-                // Video Topics
-                if (params.callVideo) {
-                    if(topics.indexOf(callTopics['receiveVideoTopic']) !== -1) {
-                        const receiveVideoOptions = {
-                            remoteVideo: uiRemoteMedias[callTopics['receiveVideoTopic']],
-                            mediaConstraints: {audio: false, video: true},
-                            iceTransportPolicy: 'relay',
-                            onicecandidate: (candidate) => {
-                                if (webpeersMetadata[callTopics['receiveVideoTopic']].interval !== null) {
-                                    clearInterval(webpeersMetadata[callTopics['receiveVideoTopic']].interval);
-                                }
-                                webpeersMetadata[callTopics['receiveVideoTopic']].interval = setInterval(function () {
-                                    if (webpeersMetadata[callTopics['receiveVideoTopic']].sdpAnswerReceived === true) {
-                                        webpeersMetadata[callTopics['receiveVideoTopic']].sdpAnswerReceived = false;
-                                        clearInterval(webpeersMetadata[callTopics['receiveVideoTopic']].interval);
-                                        sendCallMessage({
-                                            id: 'ADD_ICE_CANDIDATE',
-                                            topic: callTopics['receiveVideoTopic'],
-                                            candidateDto: candidate
-                                        })
-                                    }
-                                }, 500, {candidate: candidate});
-                            },
-                            configuration: {
-                                iceServers: turnServers
-                            }
-                        };
-
-                        webpeers[callTopics['receiveVideoTopic']] = new KurentoUtils.WebRtcPeer.WebRtcPeerRecvonly(receiveVideoOptions, function (err) {
-                            if (err) {
-                                console.error("[start/webRtcReceiveVideoPeer] Error: " + explainUserMediaError(err, 'video'));
-                                return;
-                            }
-
-                            watchRTCPeerConnection(callTopics['receiveVideoTopic']);
-
-                            webpeers[callTopics['receiveVideoTopic']].generateOffer((err, sdpOffer) => {
-                                if (err) {
-                                    console.error("[start/WebRtcVideoPeerReceiveOnly/generateOffer] " + err);
-                                    return;
-                                }
-
-                                sendCallMessage({
-                                    id: 'RECIVE_SDP_OFFER',
-                                    sdpOffer: sdpOffer,
-                                    useComedia: true,
-                                    useSrtp: false,
-                                    topic: callTopics['receiveVideoTopic'],
-                                    mediaType: 2
-                                });
+                        if (user.peers[topic].peerConnection.connectionState === "failed") {
+                            chatEvents.fireEvent('callEvents', {
+                                type: 'CALL_STATUS',
+                                errorCode: 7000,
+                                errorMessage: `Call Peer (${topic}) has failed!`,
+                                errorInfo: user.peers[topic]
                             });
-                        });
-                    }
+                            // setTimeout(function () {
 
-                    if(topics.indexOf(callTopics['sendVideoTopic']) !== -1) {
-                        const sendVideoOptions = {
-                            localVideo: uiRemoteMedias[callTopics['sendVideoTopic']],
-                            mediaConstraints: {
-                                audio: false,
-                                video: {
-                                    width: callVideoMinWidth,
-                                    height: callVideoMinHeight,
-                                    framerate: 15
-                                }
-                            },
-                            iceTransportPolicy: 'relay',
-                            onicecandidate: (candidate) => {
-                                if (webpeersMetadata[callTopics['sendVideoTopic']].interval !== null) {
-                                    clearInterval(webpeersMetadata[callTopics['sendVideoTopic']].interval);
-                                }
-                                webpeersMetadata[callTopics['sendVideoTopic']].interval = setInterval(function () {
-                                    if (webpeersMetadata[callTopics['sendVideoTopic']].sdpAnswerReceived === true) {
-                                        webpeersMetadata[callTopics['sendVideoTopic']].sdpAnswerReceived = false;
-                                        clearInterval(webpeersMetadata[callTopics['sendVideoTopic']].interval);
-                                        sendCallMessage({
-                                            id: 'ADD_ICE_CANDIDATE',
-                                            topic: callTopics['sendVideoTopic'],
-                                            candidateDto: candidate
-                                        })
-                                    }
-                                }, 500, {candidate: candidate});
-
-                            },
-                            configuration: {
-                                iceServers: turnServers
+                            if(chatMessaging.chatState) {
+                                callController.shouldReconnectTopic(userId, topic, mediaType, direction);
                             }
-                        };
-
-                        setTimeout(function () {
-                            webpeers[callTopics['sendVideoTopic']] = new KurentoUtils.WebRtcPeer.WebRtcPeerSendonly(sendVideoOptions, function (err) {
-                                if (err) {
-                                    sendCallSocketError("[start/WebRtcVideoPeerSendOnly] Error: " + explainUserMediaError(err, 'video'));
-                                    //callStop();
-                                    return;
-                                }
+                            // }, 7000);
+                            //callController.removeConnectionQualityInterval(userId, topic);
+                        }
 
-                                watchRTCPeerConnection(callTopics['sendVideoTopic']);
-                                startMedia(uiRemoteMedias[callTopics['sendVideoTopic']]);
+                        if(user.peers[topic].peerConnection.connectionState === 'connected') {
+                            if(mediaType === 'video' && direction === 'send') {
+                                user.topicMetaData[topic].connectionQualityInterval = setInterval(function() {
+                                    callController.checkConnectionQuality(userId, topic, mediaType, direction)
+                                }, 1000);
+                            }
+                        }
+                    }
 
-                                webpeers[callTopics['sendVideoTopic']].generateOffer((err, sdpOffer) => {
-                                    if (err) {
-                                        sendCallSocketError("[start/WebRtcVideoPeerSendOnly/generateOffer] Error: " + err);
-                                        //callStop();
-                                        return;
-                                    }
+                    user.peers[topic].peerConnection.oniceconnectionstatechange = function () {
+                        if(!user || !user.peers || !user.peers[topic]) {
+                            return; //avoid log errors
+                        }
 
-                                    sendCallMessage({
-                                        id: 'SEND_SDP_OFFER',
-                                        topic: callTopics['sendVideoTopic'],
-                                        sdpOffer: sdpOffer,
-                                        mediaType: 2
-                                    });
-                                });
+                        consoleLogging && console.log("[SDK][oniceconnectionstatechange] ", "peer: ", topic, " peerConnection.connectionState: ", user.peers[topic].peerConnection.iceConnectionState);
+                        if (user.peers[topic].peerConnection.iceConnectionState === 'disconnected') {
+                            chatEvents.fireEvent('callEvents', {
+                                type: 'CALL_STATUS',
+                                errorCode: 7000,
+                                errorMessage: `Call Peer (${topic}) is disconnected!`,
+                                errorInfo: user.peers[topic]
                             });
-                        }, 2000);
-                    }
-                }
 
-                // Audio Topics
-                if (params.callAudio) {
-                    if(topics.indexOf(callTopics['receiveAudioTopic']) !== -1) {
-                        const receiveAudioOptions = {
-                            remoteVideo: uiRemoteMedias[callTopics['receiveAudioTopic']],
-                            mediaConstraints: {audio: true, video: false},
-                            iceTransportPolicy: 'relay',
-                            onicecandidate: (candidate) => {
-                                if (webpeersMetadata[callTopics['receiveAudioTopic']].interval !== null) {
-                                    clearInterval(webpeersMetadata[callTopics['receiveAudioTopic']].interval);
-                                }
-                                webpeersMetadata[callTopics['receiveAudioTopic']].interval = setInterval(function () {
-                                    if (webpeersMetadata[callTopics['receiveAudioTopic']].sdpAnswerReceived === true) {
-                                        webpeersMetadata[callTopics['receiveAudioTopic']].sdpAnswerReceived = false;
-                                        clearInterval(webpeersMetadata[callTopics['receiveAudioTopic']].interval);
-                                        sendCallMessage({
-                                            id: 'ADD_ICE_CANDIDATE',
-                                            topic: callTopics['receiveAudioTopic'],
-                                            candidateDto: candidate,
-                                        })
-                                    }
-                                }, 500, {candidate: candidate});
-                            },
-                            configuration: {
-                                iceServers: turnServers
-                            }
-                        };
+                            consoleLogging && console.log('[SDK][oniceconnectionstatechange]:[disconnected] Internet connection failed, Reconnect your call, topic:', topic);
+                        }
 
-                        webpeers[callTopics['receiveAudioTopic']] = new KurentoUtils.WebRtcPeer.WebRtcPeerRecvonly(receiveAudioOptions, function (err) {
-                            if (err) {
-                                console.error("[start/WebRtcAudioPeerReceiveOnly] Error: " + explainUserMediaError(err, 'audio'));
-                                return;
+                        if (user.peers[topic].peerConnection.iceConnectionState === "failed") {
+                            chatEvents.fireEvent('callEvents', {
+                                type: 'CALL_STATUS',
+                                errorCode: 7000,
+                                errorMessage: `Call Peer (${topic}) has failed!`,
+                                errorInfo: user.peers[topic]
+                            });
+                            if(chatMessaging.chatState) {
+                                callController.shouldReconnectTopic(userId, topic, mediaType, direction);
+                                //callController.removeConnectionQualityInterval(userId, topic);
                             }
+                            // } else {
+                            //     setTimeout(function () {
+                            //         if(chatMessaging.chatState) {
+                            //             callController.shouldReconnectTopic(userId, topic, mediaType, direction);
+                            //         }
+                            //     }, 7000);
+                            // }
+                        }
 
-                            watchRTCPeerConnection(callTopics['receiveAudioTopic']);
-
-                            webpeers[callTopics['receiveAudioTopic']].generateOffer((err, sdpOffer) => {
-                                if (err) {
-                                    console.error("[start/WebRtcAudioPeerReceiveOnly/generateOffer] " + err);
-                                    return;
-                                }
-                                sendCallMessage({
-                                    id: 'RECIVE_SDP_OFFER',
-                                    sdpOffer: sdpOffer,
-                                    useComedia: false,
-                                    useSrtp: false,
-                                    mediaType: 1,
-                                    topic: callTopics['receiveAudioTopic']
-                                });
+                        if (user.peers[topic].peerConnection.iceConnectionState === "connected") {
+                            callRequestController.callEstablishedInMySide = true;
+                            chatEvents.fireEvent('callEvents', {
+                                type: 'CALL_STATUS',
+                                errorCode: 7000,
+                                errorMessage: `Call Peer (${topic}) has connected!`,
+                                errorInfo: user.peers[topic]
                             });
-                        });
+                        }
                     }
+                },
+                shouldReconnectTopic: function (userId, topic, mediaType, direction) {
+                    var callController = this, iceConnectionState = callUsers[userId].peers[topic].peerConnection.iceConnectionState;
+                    if (currentCallParams && Object.keys(currentCallParams).length) {
+                        if (callUsers[userId]
+                            && callUsers[userId].peers[topic]
+                            && iceConnectionState != 'connected') {
+                            chatEvents.fireEvent('callEvents', {
+                                type: 'CALL_STATUS',
+                                errorCode: 7000,
+                                errorMessage: `Call Peer (${topic}) is not in connected state, Restarting call in progress ...!`,
+                                errorInfo: callUsers[userId].peers[topic]
+                            });
 
-                    if(topics.indexOf(callTopics['sendAudioTopic']) !== -1) {
-                        const sendAudioOptions = {
-                            localVideo: uiRemoteMedias[callTopics['sendAudioTopic']],
-                            mediaConstraints: {audio: true, video: false},
-                            iceTransportPolicy: 'relay',
-                            onicecandidate: (candidate) => {
-                                if (webpeersMetadata[callTopics['sendAudioTopic']].interval !== null) {
-                                    clearInterval(webpeersMetadata[callTopics['sendAudioTopic']].interval);
-                                }
-                                webpeersMetadata[callTopics['sendAudioTopic']].interval = setInterval(function () {
-                                    if (webpeersMetadata[callTopics['sendAudioTopic']].sdpAnswerReceived === true) {
-                                        webpeersMetadata[callTopics['sendAudioTopic']].sdpAnswerReceived = false;
-                                        clearInterval(webpeersMetadata[callTopics['sendAudioTopic']].interval);
-                                        sendCallMessage({
-                                            id: 'ADD_ICE_CANDIDATE',
-                                            topic: callTopics['sendAudioTopic'],
-                                            candidateDto: candidate,
-                                        })
-                                    }
-                                }, 500, {candidate: candidate});
-                            },
-                            configuration: {
-                                iceServers: turnServers
-                            }
-                        };
-
-                        setTimeout(function () {
-                            webpeers[callTopics['sendAudioTopic']] = new KurentoUtils.WebRtcPeer.WebRtcPeerSendonly(sendAudioOptions, function (err) {
-                                if (err) {
-                                    sendCallSocketError("[start/WebRtcAudioPeerSendOnly] Error: " + explainUserMediaError(err, 'audio'));
-                                    //callStop();
-                                    return;
-                                }
-                                watchRTCPeerConnection(callTopics['sendAudioTopic']);
-                                startMedia(uiRemoteMedias[callTopics['sendAudioTopic']]);
-
-                                webpeers[callTopics['sendAudioTopic']].generateOffer((err, sdpOffer) => {
-                                    if (err) {
-                                        sendCallSocketError("[start/WebRtcAudioPeerSendOnly/generateOffer] Error: " + err);
-                                        //callStop();
-                                        return;
-                                    }
-                                    sendCallMessage({
-                                        id: 'SEND_SDP_OFFER',
-                                        topic: callTopics['sendAudioTopic'],
-                                        sdpOffer: sdpOffer,
-                                        mediaType: 1
+                            sendCallMessage({
+                                id: 'STOP',
+                                topic: topic
+                            }, function (result) {
+                                if (result.done === 'TRUE') {
+                                    clearInterval(callUsers[userId].topicMetaData[topic].interval)
+                                    callController.removeTopic(userId, topic);
+                                    callController.createTopic(userId, topic, mediaType, direction, userId === 'screenShare');
+                                } else if (result.done === 'SKIP') {
+                                    clearInterval(callUsers[userId].topicMetaData[topic].interval)
+                                    callController.removeTopic(userId, topic);
+                                    callController.createTopic(userId, topic, mediaType, direction, userId === 'screenShare');
+                                    //generateAndSendSdpOffers(currentCallParams, [topicName]);
+                                } else {
+                                    consoleLogging && console.log('STOP topic faced a problem', result);
+                                    endCall({
+                                        callId: currentCallId
                                     });
-                                });
+                                    callStop();
+                                }
                             });
-                        }, 2000);
+                        }
                     }
-                }
+                },
+                maybeReconnectAllTopics: function (){
+                    if(!callUsers || !Object.keys(callUsers).length || !callRequestController.callEstablishedInMySide)
+                        return;
 
-                /!*setTimeout(function () {
-                    for (var peer in webpeers) {
-                        console.log("set callback on webpeers: ",  peer);
-                        if (webpeers[peer]) {
-                            webpeers[peer].peerConnection.onconnectionstatechange = function () {
-                                console.log("on connection state change, ", "peer: ", peer, "peerConnection.connectionState: ", webpeers[peer].peerConnection.connectionState);
-                                if (webpeers[peer].peerConnection.connectionState == 'disconnected') {
-                                    console.log(peer, 'peerConnection.onconnectionstatechange: disconnected');
-                                }
+                    for(var i in callUsers) {
+                        var videoTopic = callUsers[i].videoTopicName, audioTopic = callUsers[i].audioTopicName;
+                        if(callUsers[i] && callUsers[i].peers[videoTopic] && callUsers[i].peers[videoTopic].peerConnection.connectionState === 'failed'){
+                            this.shouldReconnectTopic(i, videoTopic, 'video', callUsers[i].direction)
+                        }
+                        if(callUsers[i] && callUsers[i].peers[audioTopic] && callUsers[i].peers[audioTopic].peerConnection.connectionState === 'failed'){
+                            this.shouldReconnectTopic(i, audioTopic, 'audio', callUsers[i].direction)
+                        }
+                    }
+                },
+                removeConnectionQualityInterval: function (userId, topic) {
+                    callUsers[userId].topicMetaData[topic]['poorConnectionCount'] = 0;
+                    clearInterval(callUsers[userId].topicMetaData[topic]['connectionQualityInterval']);
+                },
+                removeStreamFromWebRTC : function (userId, topic) {
+                    if(callUsers[userId].htmlElements[topic]){
+                        const stream = callUsers[userId].htmlElements[topic].srcObject;
+                        if (!!stream) {
+                            const tracks = stream.getTracks();
+
+                            if (!!tracks) {
+                                tracks.forEach(function (track) {
+                                    track.stop();
+                                });
                             }
 
-                            webpeers[peer].peerConnection.oniceconnectionstatechange = function () {
-                                console.log("on ice connection state change:  ", peer, webpeers[peer].peerConnection.connectionState);
-                                if (webpeers[peer].peerConnection.iceConnectionState == 'disconnected') {
-                                    console.log(  peer , '>>>>>>>>>>>>> disconnected');
-                                    chatEvents.fireEvent('callEvents', {
-                                        type: 'CALL_STATUS',
-                                        errorCode: 7000,
-                                        errorMessage: `Call Peer (${peer}) is disconnected!`,
-                                        errorInfo: webpeers[peer]
-                                    });
+                            callUsers[userId].htmlElements[topic].srcObject = null;
+                        }
 
-                                    setTimeout(function () {
-                                        restartMedia(callTopics['sendVideoTopic'])
-                                    }, 2000);
+                        callUsers[userId].htmlElements[topic].remove();
+                        delete (callUsers[userId].htmlElements[topic]);
+                    }
+                },
+                addScreenShareToCall: function (direction, shareScreen) {
+                    if(direction !== callUsers["screenShare"].direction) {
+                        callUsers['screenShare'].direction = direction
+                    }
+                    var callController = this,
+                        screenShare = callUsers["screenShare"];
+                    if(!screenShare.peers[screenShare.videoTopicName]) {
+                        // Local Video Tag
+                        if(!screenShare.htmlElements[screenShare.videoTopicName]) {
+                            callStateController.generateHTMLElements('screenShare');
+                        }
+                        setTimeout(function () {
+                            callStateController.appendUserToCallDiv('screenShare');
+                            callStateController.createTopic('screenShare', screenShare.videoTopicName, "video", direction, shareScreen);
+                        });
+                        chatEvents.fireEvent('callEvents', {
+                            type: 'CALL_DIVS',
+                            result: generateCallUIList()
+                        });
+                    } else {
+                        callStateController.removeTopic('screenShare', screenShare.videoTopicName);
+                        callStateController.createTopic('screenShare', screenShare.videoTopicName, "video", direction, shareScreen);
+                        startMedia(screenShare.htmlElements[screenShare.videoTopicName])
+                    }
+                },
+                removeScreenShareFromCall: function (topic) {
+                    var callController = this,
+                        screenShare = callUsers["screenShare"];
+                    if(screenShare.peers[screenShare.videoTopicName]) {
+                        // Local Video Tag
+
+                        //removeStreamFromWebRTC(callTopics['screenShare']);
+                        callStateController.removeStreamFromWebRTC('screenShare', screenShare.videoTopicName)
+                        callStateController.removeTopic('screenShare', screenShare.videoTopicName);
+                        chatEvents.fireEvent('callEvents', {
+                            type: 'CALL_DIVS',
+                            result: generateCallUIList()
+                        });
+                    }
+                },
+                removeAllCallParticipants: function () {
+                    var removeAllUsersPromise = new Promise(function (resolve, reject) {
+                        for (var i in callUsers) {
+                            var user = callUsers[i];
+                            if (user) {
+                                if(user.videoTopicName && user.peers[user.videoTopicName]) {
+                                    clearInterval(callUsers[i].topicMetaData[user.videoTopicName].interval);
+                                    callStateController.removeConnectionQualityInterval(i, user.videoTopicName);
+                                    callStateController.removeStreamFromWebRTC(i, user.videoTopicName);
+                                    callUsers[i].peers[user.videoTopicName].dispose();
+                                    delete callUsers[i].peers[user.videoTopicName];
 
-                                    setTimeout(function () {
-                                        restartMedia(callTopics['sendVideoTopic'])
-                                    }, 6000);
-
-                                    alert('Internet connection failed, Reconnect your call');
-                                    /!*shouldReconnectCallTimeout && clearTimeout(shouldReconnectCallTimeout);
-                                    shouldReconnectCallTimeout = setTimeout(function () {
-                                        shouldReconnectCall();
-                                    }, 7000);*!/
                                 }
+                                if(user.audioTopicName && user.peers[user.audioTopicName]) {
+                                    clearInterval(callUsers[i].topicMetaData[user.audioTopicName].interval);
+                                    callStateController.removeConnectionQualityInterval(i, user.audioTopicName);
+                                    callStateController.removeStreamFromWebRTC(i, user.audioTopicName);
 
-                                if (webpeers[peer].peerConnection.iceConnectionState === "failed") {
-                                    chatEvents.fireEvent('callEvents', {
-                                        type: 'CALL_STATUS',
-                                        errorCode: 7000,
-                                        errorMessage: `Call Peer (${peer}) has failed!`,
-                                        errorInfo: webpeers[peer]
-                                    });
+                                    callUsers[i].peers[user.audioTopicName].dispose();
+                                    delete callUsers[i].peers[user.audioTopicName];
                                 }
+                                setTimeout(function (){
+                                    if(callUsers[i]){
+                                        callUsers[i].peers = {};
+                                        callUsers[i].topicMetaData = {};
+                                        callUsers[i].htmlElements = {};
+                                        callUsers[i] = null;
+                                    }
 
-                                if (webpeers[peer].peerConnection.iceConnectionState === "connected") {
-                                    chatEvents.fireEvent('callEvents', {
-                                        type: 'CALL_STATUS',
-                                        errorCode: 7000,
-                                        errorMessage: `Call Peer (${peer}) has connected!`,
-                                        errorInfo: webpeers[peer]
-                                    });
-
-                                    setTimeout(function () {
-                                        restartMedia(callTopics['sendVideoTopic'])
-                                    }, 2000);
-
-                                    setTimeout(function () {
-                                        restartMedia(callTopics['sendVideoTopic'])
-                                    }, 6000);
-                                }
+                                    resolve()
+                                }, 200);
                             }
                         }
-                    }
-                }, 6000);*!/
+                    });
 
-                setTimeout(function () {
-                    restartMedia(callTopics['sendVideoTopic'])
-                }, 4000);
-                setTimeout(function () {
-                    restartMedia(callTopics['sendVideoTopic'])
-                }, 8000);
-                setTimeout(function () {
-                    restartMedia(callTopics['sendVideoTopic'])
-                }, 12000);
-                setTimeout(function () {
-                    restartMedia(callTopics['sendVideoTopic'])
-                }, 20000);
-            },
+                    removeAllUsersPromise.then(function (){
+                        callUsers = {};
+                    });
+                },
+                removeFromCallUI: function (topic) {
+                    var videoElement = 'Vi-' + topic,
+                        audioElement = 'Vo-' + topic,
+                        userId = this.findUserIdByTopic(videoElement);
 
-            watchRTCPeerConnection = function (topic) {
-                console.log("set callback on webpeers: ", topic);
-                if (webpeers[topic]) {
-                    webpeers[topic].peerConnection.onconnectionstatechange = function () {
-                        console.log("on connection state change, ", "peer: ", topic, "peerConnection.connectionState: ", webpeers[topic].peerConnection.connectionState);
-                        if (webpeers[topic].peerConnection.connectionState == 'disconnected') {
-                            console.log(topic, 'peerConnection.onconnectionstatechange: disconnected');
-                        }
+                    if (topic.length > 0 && callUsers[userId].htmlElements[videoElement]) {
+                        this.removeStreamFromWebRTC(userId,videoElement);
                     }
 
-                    webpeers[topic].peerConnection.oniceconnectionstatechange = function () {
-                        console.log("on ice connection state change:  ", topic, webpeers[topic].peerConnection.iceConnectionState);
-                        if (webpeers[topic].peerConnection.iceConnectionState == 'disconnected') {
-                            console.log(topic, 'peerConnection.oniceconnectionstatechange disconnected');
-                            chatEvents.fireEvent('callEvents', {
-                                type: 'CALL_STATUS',
-                                errorCode: 7000,
-                                errorMessage: `Call Peer (${topic}) is disconnected!`,
-                                errorInfo: webpeers[topic]
-                            });
-
-                            /!*setTimeout(function () {
-                                restartMedia(callTopics['sendVideoTopic'])
-                            }, 2000);*!/
-
-                            /!*setTimeout(function () {
-                                restartMedia(callTopics['sendVideoTopic'])
-                            }, 6000);*!/
-
-                            console.log('Internet connection failed, Reconnect your call, topic:', topic);
-                            //shouldReconnectCallTimeout && clearTimeout(shouldReconnectCallTimeout);
-                            /!*shouldReconnectCallTimeout = setTimeout(function () {
-                                shouldReconnectCall(topic);
-                            }, 7000);*!/
+                    if (topic.length > 0 && callUsers[userId].htmlElements[videoElement]) {
+                        this.removeStreamFromWebRTC(userId, audioElement);
+                    }
+                },
+                findUserIdByTopic: function (topic) {
+                    for(var i in callUsers) {
+                        if (callUsers[i].videoTopicName === topic || callUsers[i].audioTopicName === topic) {
+                            //peer = callUsers[i].peers[jsonMessage.topic];
+                            return i;
                         }
+                    }
+                },
+                activateParticipantStream: function (userId, mediaType, direction, topicNameKey, sendTopic, mediaKey) {
+                    if(callUsers[userId]) {
+                        callUsers[userId][mediaKey] = (mediaKey !== 'mute');
+                        callUsers[userId][topicNameKey] = (mediaType === 'audio'?  'Vo-':  'Vi-') + sendTopic;
 
-                        if (webpeers[topic].peerConnection.iceConnectionState === "failed") {
-                            chatEvents.fireEvent('callEvents', {
-                                type: 'CALL_STATUS',
-                                errorCode: 7000,
-                                errorMessage: `Call Peer (${topic}) has failed!`,
-                                errorInfo: webpeers[topic]
-                            });
-
-                            if(chatMessaging.chatState) {
-                                shouldReconnectCall(topic);
-                            } else {
-                                setTimeout(function () {
-                                    if(chatMessaging.chatState) {
-                                        shouldReconnectCall(topic);
-                                    }
-                                }, 5000);
-                            }
+                        var user = callUsers[userId];
+                        callStateController.appendUserToCallDiv(userId, callStateController.generateHTMLElements(userId));
+                        setTimeout(function () {
+                            callStateController.createTopic(userId, user[topicNameKey], mediaType, direction);
+                        })
+                    }
+                },
+                deactivateParticipantStream: function (userId, topicNameKey, mediaKey) {
+                    callUsers[userId][mediaKey] = false;
+                    var user = callUsers[userId];
+                    clearInterval(callUsers[userId].topicMetaData[user[topicNameKey]].interval)
+                    callStateController.removeTopic(userId, user[topicNameKey]);
+                    callStateController.removeStreamFromWebRTC(userId, user[topicNameKey]);
+                },
+                setMediaBitrates: function (sdp) {
+                    return this.setMediaBitrate(this.setMediaBitrate(sdp, "video", 400), "audio", 50);
+                },
+                setMediaBitrate: function (sdp, media, bitrate) {
+                    var lines = sdp.split("\n");
+                    var line = -1;
+                    for (var i = 0; i < lines.length; i++) {
+                        if (lines[i].indexOf("m=" + media) === 0) {
+                            line = i;
+                            break;
                         }
+                    }
+                    if (line === -1) {
+                        consoleLogging && console.debug("[SDK][setMediaBitrate] Could not find the m line for", media);
+                        return sdp;
+                    }
+                    consoleLogging && console.debug("[SDK][setMediaBitrate] Found the m line for", media, "at line", line);
 
-                        if (webpeers[topic].peerConnection.iceConnectionState === "connected") {
-                            callRequestController.callEstablishedInMySide = true;
-                            chatEvents.fireEvent('callEvents', {
-                                type: 'CALL_STATUS',
-                                errorCode: 7000,
-                                errorMessage: `Call Peer (${topic}) has connected!`,
-                                errorInfo: webpeers[topic]
-                            });
+                    // Pass the m line
+                    line++;
 
-                            /!*setTimeout(function () {
-                                restartMedia(callTopics['sendVideoTopic'])
-                            }, 2000);*!/
+                    // Skip i and c lines
+                    /* while (lines[line].indexOf("i=") === 0 || lines[line].indexOf("c=") === 0) {
+                        line++;
+                    }*/
 
-                            /!*setTimeout(function () {
-                                restartMedia(callTopics['sendVideoTopic'])
-                            }, 6000);*!/
-                        }
+                    // If we're on a b line, replace it
+                    if (lines[line].indexOf("b") === 0) {
+                        consoleLogging && console.debug("[SDK][setMediaBitrate] Replaced b line at line", line);
+                        lines[line] = "b=AS:" + bitrate;
+                        return lines.join("\n");
                     }
-                }
 
+                    // Add a new b line
+                    consoleLogging && console.debug("[SDK][setMediaBitrate] Adding new b line before line", line);
+                    var newLines = lines.slice(0, line);
+                    newLines.push("b=AS:" + bitrate + "\r");
+                    newLines = newLines.concat(lines.slice(line, lines.length));
+                    consoleLogging && console.debug("[SDK][setMediaBitrate] output: ", newLines.join("\n"));
+                    return newLines.join("\n")
+                },
             },
-*/
 
             sendCallSocketError = function (message) {
                 chatEvents.fireEvent('callEvents', {
@@ -56298,7 +57646,7 @@ WildEmitter.mixin(WildEmitter);
                 });
             },
 
-            explainUserMediaError = function (err, deviceType) {
+            explainUserMediaError = function (err, deviceType, deviceSource) {
                 chatEvents.fireEvent('callEvents', {
                     type: 'CALL_ERROR',
                     code: 7000,
@@ -56335,10 +57683,10 @@ WildEmitter.mixin(WildEmitter);
                     chatEvents.fireEvent('callEvents', {
                         type: 'CALL_ERROR',
                         code: 7000,
-                        message: (deviceType === 'video' ? 'Webcam' : 'Mice') + " permission has been denied by the user"
+                        message: (deviceType === 'video' ? (deviceSource === 'screen'? 'ScreenShare' : 'Webcam') : 'Mice') + " permission has been denied by the user"
                     });
-                    alert((deviceType === 'video' ? 'Webcam' : 'Mice') + " permission has been denied by the user");
-                    return (deviceType === 'video' ? 'Webcam' : 'Mice') + " permission has been denied by the user";
+                    alert((deviceType === 'video' ? (deviceSource === 'screen'? 'ScreenShare' : 'Webcam') : 'Mice') + " permission has been denied by the user");
+                    return (deviceType === 'video' ? (deviceSource === 'screen'? 'ScreenShare' : 'Webcam') : 'Mice') + " permission has been denied by the user";
                 } else if (n === 'TypeError') {
                     chatEvents.fireEvent('callEvents', {
                         type: 'CALL_ERROR',
@@ -56363,19 +57711,19 @@ WildEmitter.mixin(WildEmitter);
             },
 
             startMedia = function (media) {
-                consoleLogging && console.log("startMedia:: ", media);
+                consoleLogging && console.log("[SDK][startMedia] called with: ", media);
                 media.play().catch((err) => {
                     if (err.name === 'NotAllowedError') {
                         chatEvents.fireEvent('callEvents', {
                             type: 'CALL_ERROR',
                             code: 7000,
-                            message: "[start] Browser doesn't allow playing media: " + err
+                            message: "[startMedia] Browser doesn't allow playing media: " + err
                         });
                     } else {
                         chatEvents.fireEvent('callEvents', {
                             type: 'CALL_ERROR',
                             code: 7000,
-                            message: "[start] Error in media.play(): " + err
+                            message: "[startMedia] Error in media.play(): " + err
                         });
                     }
                 });
@@ -56383,9 +57731,9 @@ WildEmitter.mixin(WildEmitter);
 
             restartMedia = function (videoTopicParam) {
                 if (currentCallParams && Object.keys(currentCallParams).length) {
-                    consoleLogging && console.log('Sending Key Frame ...');
+                    consoleLogging && console.log('[SDK] Sending Key Frame ...');
 
-                    var videoTopic = !!videoTopicParam ? videoTopicParam : callTopics['sendVideoTopic'];
+                    var videoTopic = !!videoTopicParam ? videoTopicParam : callUsers[chatMessaging.userInfo.id].videoTopicName;//callTopics['sendVideoTopic'];
                     let videoElement = document.getElementById(`uiRemoteVideo-${videoTopic}`);
 
                     if (videoElement) {
@@ -56439,19 +57787,20 @@ WildEmitter.mixin(WildEmitter);
             },
 
             handleProcessSdpAnswer = function (jsonMessage) {
-                let sampleWebRtc = webpeers[jsonMessage.topic];
+                var userId = callStateController.findUserIdByTopic(jsonMessage.topic),
+                 peer = callUsers[userId].peers[jsonMessage.topic];
 
-                if (sampleWebRtc == null) {
+                if (peer == null) {
                     chatEvents.fireEvent('callEvents', {
                         type: 'CALL_ERROR',
                         code: 7000,
                         message: "[handleProcessSdpAnswer] Skip, no WebRTC Peer",
-                        error: webpeers[jsonMessage.topic]
+                        error: peer
                     });
                     return;
                 }
 
-                sampleWebRtc.processAnswer(jsonMessage.sdpAnswer, (err) => {
+                peer.processAnswer(jsonMessage.sdpAnswer, (err) => {
                     if (err) {
                         sendCallSocketError("[handleProcessSdpAnswer] Error: " + err);
 
@@ -56464,26 +57813,35 @@ WildEmitter.mixin(WildEmitter);
                         return;
                     }
 
-                    if (webpeersMetadata[jsonMessage.topic].interval !== null) {
-                        webpeersMetadata[jsonMessage.topic].sdpAnswerReceived = true;
+                    if (callUsers[userId].topicMetaData[jsonMessage.topic].interval !== null) {
+                        callUsers[userId].topicMetaData[jsonMessage.topic].sdpAnswerReceived = true;
+                    }
+                    consoleLogging && console.log("[SDK][handleProcessSdpAnswer]", jsonMessage, jsonMessage.topic)
+                    startMedia(callUsers[userId].htmlElements[jsonMessage.topic]);
+                    if(userId === 'screenShare') {
+                        restartMediaOnKeyFrame("screenShare", 2000);
+                        restartMediaOnKeyFrame("screenShare", 4000);
+                        restartMediaOnKeyFrame("screenShare", 8000);
+                        restartMediaOnKeyFrame("screenShare", 12000);
                     }
-                    startMedia(uiRemoteMedias[jsonMessage.topic]);
                 });
             },
 
             handleAddIceCandidate = function (jsonMessage) {
-                let sampleWebRtc = webpeers[jsonMessage.topic];
-                if (sampleWebRtc == null) {
+                var userId = callStateController.findUserIdByTopic(jsonMessage.topic);
+
+                let peer = callUsers[userId].peers[jsonMessage.topic];
+                if (peer == null) {
                     chatEvents.fireEvent('callEvents', {
                         type: 'CALL_ERROR',
                         code: 7000,
                         message: "[handleAddIceCandidate] Skip, no WebRTC Peer",
-                        error: JSON.stringify(webpeers[jsonMessage.topic])
+                        error: JSON.stringify(peer)
                     });
                     return;
                 }
 
-                sampleWebRtc.addIceCandidate(jsonMessage.candidate, (err) => {
+                peer.addIceCandidate(jsonMessage.candidate, (err) => {
                     if (err) {
                         console.error("[handleAddIceCandidate] " + err);
 
@@ -56522,19 +57880,7 @@ WildEmitter.mixin(WildEmitter);
             },
 
             callStop = function () {
-                consoleLogging && console.log('Call is stopping ...');
-
-                for (var media in uiRemoteMedias) {
-                    removeStreamFromWebRTC(media);
-                }
-
-                for (var i in webpeers) {
-                    if (webpeers[i]) {
-                        callStateController.removeConnectionQualityInterval(i);
-                        webpeers[i].dispose();
-                        webpeers[i] = null;
-                    }
-                }
+                callStateController.removeAllCallParticipants();
 
                 if (callStopQueue.callStarted) {
                     sendCallMessage({
@@ -56543,45 +57889,56 @@ WildEmitter.mixin(WildEmitter);
                     callStopQueue.callStarted = false;
                 }
 
+                callRequestController.cameraPaused = false;
                 callRequestController.callEstablishedInMySide = false;
                 callRequestController.callRequestReceived = false;
                 currentCallParams = {};
                 currentCallId = null;
             },
 
-            removeStreamFromWebRTC = function (RTCStream) {
-                var callParentDiv = document.getElementById(callDivId);
+            /*
+                        removeStreamFromWebRTC = function (RTCStream) {
+                            var callParentDiv = document.getElementById(callDivId);
 
-                if (uiRemoteMedias.hasOwnProperty(RTCStream)) {
-                    const stream = uiRemoteMedias[RTCStream].srcObject;
-                    if (!!stream) {
-                        const tracks = stream.getTracks();
+                            if (uiRemoteMedias.hasOwnProperty(RTCStream)) {
+                                const stream = uiRemoteMedias[RTCStream].srcObject;
+                                if (!!stream) {
+                                    const tracks = stream.getTracks();
 
-                        if (!!tracks) {
-                            tracks.forEach(function (track) {
-                                track.stop();
-                            });
-                        }
+                                    if (!!tracks) {
+                                        tracks.forEach(function (track) {
+                                            track.stop();
+                                        });
+                                    }
 
-                        uiRemoteMedias[RTCStream].srcObject = null;
-                    }
+                                    uiRemoteMedias[RTCStream].srcObject = null;
+                                }
 
-                    uiRemoteMedias[RTCStream].remove();
-                    delete (uiRemoteMedias[RTCStream]);
-                }
-            },
+                                uiRemoteMedias[RTCStream].remove();
+                                delete (uiRemoteMedias[RTCStream]);
+                            }
+                        },
 
-            removeFromCallUI = function (topic) {
-                var videoElement = 'Vi-' + topic;
-                var audioElement = 'Vo-' + topic;
 
-                if (topic.length > 0 && uiRemoteMedias.hasOwnProperty(videoElement)) {
-                    removeStreamFromWebRTC(videoElement);
-                }
+                        removeFromCallUI = function (topic) {
+                            var videoElement = 'Vi-' + topic;
+                            var audioElement = 'Vo-' + topic;
 
-                if (topic.length > 0 && uiRemoteMedias.hasOwnProperty(audioElement)) {
-                    removeStreamFromWebRTC(audioElement);
-                }
+                            if (topic.length > 0 && uiRemoteMedias.hasOwnProperty(videoElement)) {
+                                removeStreamFromWebRTC(videoElement);
+                            }
+
+                            if (topic.length > 0 && uiRemoteMedias.hasOwnProperty(audioElement)) {
+                                removeStreamFromWebRTC(audioElement);
+                            }
+                        },
+            */
+
+            restartMediaOnKeyFrame = function (userId, timeout) {
+                setTimeout(function () {
+                    if(typeof callUsers[userId] !== "undefined" && callUsers[userId])
+                        restartMedia(callUsers[userId].videoTopicName);
+                }, timeout);
             };
 
         this.updateToken = function (newToken) {
@@ -56607,18 +57964,38 @@ WildEmitter.mixin(WildEmitter);
                     break;
 
                 case 'GET_KEY_FRAME':
-                    setTimeout(function () {
-                        restartMedia(callTopics['sendVideoTopic']);
+                    if(callUsers && callUsers[chatMessaging.userInfo.id] && callUsers[chatMessaging.userInfo.id].video) {
+                        restartMediaOnKeyFrame(chatMessaging.userInfo.id, 2000);
+                        restartMediaOnKeyFrame(chatMessaging.userInfo.id, 4000);
+                        restartMediaOnKeyFrame(chatMessaging.userInfo.id, 8000);
+                        restartMediaOnKeyFrame(chatMessaging.userInfo.id, 12000);
+                    }
+                    if(callUsers && callUsers['screenShare']
+                        && callUsers['screenShare'].video
+                        && screenShareState.started
+                        && screenShareState.imOwner) {
+                        restartMediaOnKeyFrame('screenShare', 2000);
+                        restartMediaOnKeyFrame('screenShare', 4000);
+                        restartMediaOnKeyFrame('screenShare', 8000);
+                        restartMediaOnKeyFrame('screenShare', 12000);
+                    }
+
+/*                    setTimeout(function () {
+                        if(typeof callUsers[chatMessaging.userInfo.id] === "undefined" || !callUsers[chatMessaging.userInfo.id])
+                            restartMedia(callUsers[chatMessaging.userInfo.id].videoTopicName);
                     }, 2000);
                     setTimeout(function () {
-                        restartMedia(callTopics['sendVideoTopic']);
+                        if(typeof callUsers[chatMessaging.userInfo.id] === "undefined" || !callUsers[chatMessaging.userInfo.id])
+                            restartMedia(callUsers[chatMessaging.userInfo.id].videoTopicName);
                     }, 4000);
                     setTimeout(function () {
-                        restartMedia(callTopics['sendVideoTopic']);
+                        if(typeof callUsers[chatMessaging.userInfo.id] === "undefined" || !callUsers[chatMessaging.userInfo.id])
+                            restartMedia(callUsers[chatMessaging.userInfo.id].videoTopicName);
                     }, 8000);
                     setTimeout(function () {
-                        restartMedia(callTopics['sendVideoTopic']);
-                    }, 12000);
+                        if(typeof callUsers[chatMessaging.userInfo.id] === "undefined" || !callUsers[chatMessaging.userInfo.id])
+                            restartMedia(callUsers[chatMessaging.userInfo.id].videoTopicName);
+                    }, 12000);*/
                     break;
 
                 case 'FREEZED':
@@ -56658,7 +58035,7 @@ WildEmitter.mixin(WildEmitter);
                     break;
 
                 default:
-                    console.warn("[onmessage] Invalid message, id: " + jsonMessage.id, jsonMessage);
+                    console.warn("[SDK][onmessage] Invalid message, id: " + jsonMessage.id, jsonMessage);
                     if (jsonMessage.match(/NOT CREATE SESSION/g)) {
                         if (currentCallParams && Object.keys(currentCallParams)) {
                             //handleCallSocketOpen(currentCallParams);
@@ -56670,7 +58047,11 @@ WildEmitter.mixin(WildEmitter);
         };
 
         this.asyncInitialized = function (async) {
-            asyncClient = async
+            asyncClient = async;
+
+            asyncClient.on('asyncReady', function (){
+                callStateController.maybeReconnectAllTopics();
+            })
         };
 
         this.handleChatMessages = function(type, chatMessageVOTypes, messageContent, contentCount, threadId, uniqueId) {
@@ -56774,13 +58155,7 @@ WildEmitter.mixin(WildEmitter);
                         result: messageContent
                     });
 
-                    for (var peer in webpeers) {
-                        if (webpeers[peer]) {
-                            webpeers[peer].dispose();
-                            delete webpeers[peer];
-                        }
-                    }
-                    webpeers = {};
+                    //callStateController.removeAllCallParticipants();
 
                     if (typeof messageContent === 'object'
                         && messageContent.hasOwnProperty('chatDataDto')
@@ -56793,8 +58168,10 @@ WildEmitter.mixin(WildEmitter);
                             mute: messageContent.clientDTO.mute,
                             sendingTopic: messageContent.clientDTO.topicSend,
                             receiveTopic: messageContent.clientDTO.topicReceive,
+                            screenShare: messageContent.chatDataDto.screenShare,
                             brokerAddress: messageContent.chatDataDto.brokerAddressWeb,
                             turnAddress: messageContent.chatDataDto.turnAddress,
+                            clientsList: messageContent.otherClientDtoList
                         }, function (callDivs) {
                             chatEvents.fireEvent('callEvents', {
                                 type: 'CALL_DIVS',
@@ -56881,8 +58258,9 @@ WildEmitter.mixin(WildEmitter);
                         type: 'CALL_PARTICIPANT_CONNECTED',
                         result: messageContent
                     });
-
-                    restartMedia(callTopics['sendVideoTopic']);
+//callTopics['sendVideoTopic']
+                    //restartMedia(callUsers[chatMessaging.userInfo.id].videoTopicName);
+                    restartMediaOnKeyFrame(chatMessaging.userInfo.id, 100)
 
                     break;
 
@@ -56932,7 +58310,8 @@ WildEmitter.mixin(WildEmitter);
                     });
 
                     if (!!messageContent[0].sendTopic) {
-                        removeFromCallUI(messageContent[0].sendTopic);
+                        //removeFromCallUI(messageContent[0].sendTopic);
+                        callStateController.removeFromCallUI(messageContent[0].sendTopic)
                     }
 
                     break;
@@ -56960,8 +58339,8 @@ WildEmitter.mixin(WildEmitter);
                         result: messageContent
                     });
 
-                    restartMedia(callTopics['sendVideoTopic']);
-
+                    //restartMedia(callTopics['sendVideoTopic']);
+                    restartMediaOnKeyFrame(chatMessaging.userInfo.id, 100)
                     break;
 
                 /**
@@ -57003,6 +58382,24 @@ WildEmitter.mixin(WildEmitter);
                 case chatMessageVOTypes.MUTE_CALL_PARTICIPANT:
                     if (chatMessaging.messagesCallbacks[uniqueId]) {
                         chatMessaging.messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                    } else {
+                        if(Array.isArray(messageContent)){
+                            for(var i in messageContent) {
+                                callStateController.deactivateParticipantStream(
+                                    messageContent[i].userId,
+                                    'audioTopicName',
+                                    'mute'
+                                )
+                                /*if(callUsers[messageContent[i].userId]) {
+                                    callUsers[messageContent[i].userId].mute = true;
+
+                                    var user = callUsers[messageContent[i].userId];
+                                    clearInterval(callUsers[messageContent[i].userId].topicMetaData[user.audioTopicName].interval)
+                                    callStateController.removeTopic(messageContent[i].userId, user.audioTopicName);
+                                    callStateController.removeStreamFromWebRTC(messageContent[i].userId, user.audioTopicName);
+                                }*/
+                            }
+                        }
                     }
 
                     chatEvents.fireEvent('callEvents', {
@@ -57018,6 +58415,30 @@ WildEmitter.mixin(WildEmitter);
                 case chatMessageVOTypes.UNMUTE_CALL_PARTICIPANT:
                     if (chatMessaging.messagesCallbacks[uniqueId]) {
                         chatMessaging.messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                    } else {
+                        if(Array.isArray(messageContent)) {
+                            for(var i in messageContent) {
+                                callStateController.activateParticipantStream(
+                                    messageContent[i].userId,
+                                    'audio',
+                                    'receive',
+                                    'audioTopicName',
+                                    messageContent[i].sendTopic,
+                                    'mute'
+                                );
+                                /*if(callUsers[messageContent[i].userId]) {
+                                    callUsers[messageContent[i].userId].mute = false;
+                                    callUsers[messageContent[i].userId].audioTopicName = 'Vo-' + messageContent[i].sendTopic;
+
+                                    var user = callUsers[messageContent[i].userId];
+                                    callStateController.appendUserToCallDiv(messageContent[i].userId, callStateController.generateHTMLElements(messageContent[i].userId));
+                                    setTimeout(function () {
+                                        callStateController.createTopic(messageContent[i].userId, user.audioTopicName, 'audio', 'receive');
+
+                                    })
+                                }*/
+                            }
+                        }
                     }
 
                     chatEvents.fireEvent('callEvents', {
@@ -57058,8 +58479,38 @@ WildEmitter.mixin(WildEmitter);
                 case chatMessageVOTypes.TURN_ON_VIDEO_CALL:
                     if (chatMessaging.messagesCallbacks[uniqueId]) {
                         chatMessaging.messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                    } else {
+                        if(Array.isArray(messageContent)) {
+                            for(var i in messageContent) {
+                                callStateController.activateParticipantStream(
+                                    messageContent[i].userId,
+                                    'video',
+                                    'receive',
+                                    'videoTopicName',
+                                    messageContent[i].sendTopic,
+                                    'video'
+                                );
+                                /*if(callUsers[messageContent[i].userId]) {
+                                    callUsers[messageContent[i].userId].video = true;
+                                    callUsers[messageContent[i].userId].videoTopicName = 'Vi-' + messageContent[i].sendTopic;
+
+                                    var user = callUsers[messageContent[i].userId];
+                                    callStateController.appendUserToCallDiv(messageContent[i].userId, callStateController.generateHTMLElements(messageContent[i].userId));
+                                    setTimeout(function () {
+                                        callStateController.createTopic(messageContent[i].userId, user.videoTopicName, 'video', 'receive');
+                                    })
+                                }*/
+                            }
+                        }
                     }
 
+                    setTimeout(function () {
+                        chatEvents.fireEvent('callEvents', {
+                            type: 'CALL_DIVS',
+                            result: generateCallUIList()
+                        });
+                    })
+
                     chatEvents.fireEvent('callEvents', {
                         type: 'TURN_ON_VIDEO_CALL',
                         result: messageContent
@@ -57073,8 +58524,32 @@ WildEmitter.mixin(WildEmitter);
                 case chatMessageVOTypes.TURN_OFF_VIDEO_CALL:
                     if (chatMessaging.messagesCallbacks[uniqueId]) {
                         chatMessaging.messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                    } else {
+                        if(Array.isArray(messageContent)){
+                            for(var i in messageContent) {
+                                callStateController.deactivateParticipantStream(
+                                    messageContent[i].userId,
+                                    'videoTopicName',
+                                    'video'
+                                )
+                               /* if(callUsers[messageContent[i].userId]) {
+                                    callUsers[messageContent[i].userId].video = false;
+                                    var user = callUsers[messageContent[i].userId];
+                                    clearInterval(callUsers[messageContent[i].userId].topicMetaData[user.videoTopicName].interval)
+                                    callStateController.removeTopic(messageContent[i].userId, user.videoTopicName);
+                                    callStateController.removeStreamFromWebRTC(messageContent[i].userId, user.videoTopicName);
+                                }*/
+                            }
+                        }
                     }
 
+                    setTimeout(function () {
+                        chatEvents.fireEvent('callEvents', {
+                            type: 'CALL_DIVS',
+                            result: generateCallUIList()
+                        });
+                    })
+
                     chatEvents.fireEvent('callEvents', {
                         type: 'TURN_OFF_VIDEO_CALL',
                         result: messageContent
@@ -57095,8 +58570,8 @@ WildEmitter.mixin(WildEmitter);
                         result: messageContent
                     });
 
-                    restartMedia(callTopics['sendVideoTopic']);
-
+                    //restartMedia(callTopics['sendVideoTopic']);
+                    restartMediaOnKeyFrame(chatMessaging.userInfo.id, 100)
                     break;
 
                 /**
@@ -57118,8 +58593,20 @@ WildEmitter.mixin(WildEmitter);
                  * Type 123   Start Screen Share
                  */
                 case chatMessageVOTypes.START_SCREEN_SHARE:
+                    if(!callRequestController.callEstablishedInMySide)
+                        return;
+
+                    screenShareState.started = true;
+                    if(messageContent.screenOwner.id === chatMessaging.userInfo.id) {
+                        screenShareState.imOwner = true;
+                    } else {
+                        screenShareState.imOwner = false;
+                    }
+
                     if (chatMessaging.messagesCallbacks[uniqueId]) {
                         chatMessaging.messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                    } else if(!screenShareState.imOwner) {
+                        callStateController.addScreenShareToCall("receive", false)
                     }
 
                     chatEvents.fireEvent('callEvents', {
@@ -57133,8 +58620,14 @@ WildEmitter.mixin(WildEmitter);
                  * Type 124   End Screen Share
                  */
                 case chatMessageVOTypes.END_SCREEN_SHARE:
+                    screenShareState.imOwner = false;
+                    screenShareState.started = false;
+
                     if (chatMessaging.messagesCallbacks[uniqueId]) {
                         chatMessaging.messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                    } else if (!screenShareState.imOwner) {
+                       consoleLogging && console.log("[SDK][END_SCREEN_SHARE], im not owner of screen");
+                       callStateController.removeScreenShareFromCall();
                     }
 
                     chatEvents.fireEvent('callEvents', {
@@ -57157,6 +58650,25 @@ WildEmitter.mixin(WildEmitter);
                         result: messageContent
                     });
 
+                    break;
+                /**
+                 * Type 126   Destinated Record Call Request
+                 */
+                case chatMessageVOTypes.DESTINATED_RECORD_CALL:
+                    if(!callRequestController.callEstablishedInMySide)
+                        return;
+
+                    if (chatMessaging.messagesCallbacks[uniqueId]) {
+                        chatMessaging.messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount));
+                    }
+
+                    chatEvents.fireEvent('callEvents', {
+                        type: 'START_RECORDING_CALL',
+                        result: messageContent
+                    });
+
+                    //restartMedia(callTopics['sendVideoTopic']);
+                    restartMediaOnKeyFrame(chatMessaging.userInfo.id, 100)
                     break;
             }
         }
@@ -57219,6 +58731,7 @@ WildEmitter.mixin(WildEmitter);
                 return;
             }
 
+            callRequestController.cameraPaused = (typeof params.cameraPaused === 'boolean') ? params.cameraPaused : false;
             callRequestController.callRequestReceived = true;
             callRequestController.callEstablishedInMySide = true;
 
@@ -57352,6 +58865,8 @@ WildEmitter.mixin(WildEmitter);
 
                 content.videoCall = content.video;
 
+                callRequestController.cameraPaused = (typeof params.cameraPaused === 'boolean') ? params.cameraPaused : callRequestController.cameraPaused;
+
                 if (params.clientType && typeof params.clientType === 'string' && callClientTypes[params.clientType.toUpperCase()] > 0) {
                     content.clientType = callClientTypes[params.clientType.toUpperCase()];
                 } else {
@@ -57414,7 +58929,8 @@ WildEmitter.mixin(WildEmitter);
                 chatMessageVOType: chatMessageVOTypes.RECORD_CALL,
                 typeCode: params.typeCode,
                 pushMsgType: 3,
-                token: token
+                token: token,
+                content: {}
             };
 
             if (params) {
@@ -57427,6 +58943,13 @@ WildEmitter.mixin(WildEmitter);
                     });
                     return;
                 }
+
+                if(params.destinated === true) {
+                    recordCallData.chatMessageVOType = chatMessageVOTypes.DESTINATED_RECORD_CALL;
+                    recordCallData.content.recordType = typeof +params.recordType === 'number' ? params.recordType : 1;
+                    recordCallData.content.tags = Array.isArray(params.tags) ? params.tags : null;
+                    recordCallData.content.threadId = typeof +params.threadId === 'number' ? params.threadId : null;
+                }
             } else {
                 chatEvents.fireEvent('error', {
                     code: 999,
@@ -57437,7 +58960,8 @@ WildEmitter.mixin(WildEmitter);
 
             return chatMessaging.sendMessage(recordCallData, {
                 onResult: function (result) {
-                    restartMedia(callTopics['sendVideoTopic']);
+                    //restartMedia(callTopics['sendVideoTopic']);
+                    restartMediaOnKeyFrame(chatMessaging.userInfo.id, 100)
                     callback && callback(result);
                 }
             });
@@ -57502,8 +59026,26 @@ WildEmitter.mixin(WildEmitter);
                 return;
             }
 
+            /*if(screenShareState.started) {
+                chatEvents.fireEvent('error', {
+                    code: 999,
+                    message: "ScreenShare has already started"
+                });
+                console.log("ScreenShare has already started");
+                return
+            }*/
+
             return chatMessaging.sendMessage(sendData, {
                 onResult: function (result) {
+                    consoleLogging && console.log("[sdk][startScreenShare][onResult]: ", result);
+                    if(!result.hasError) {
+                        var direction = 'send', shareScreen = true;
+                        if(screenShareState.started && !screenShareState.imOwner) {
+                            direction = 'receive';
+                            shareScreen = false;
+                        }
+                        callStateController.addScreenShareToCall(direction, shareScreen);
+                    }
                     callback && callback(result);
                 }
             });
@@ -57535,6 +59077,20 @@ WildEmitter.mixin(WildEmitter);
                 return;
             }
 
+            if(!screenShareState.imOwner) {
+                chatEvents.fireEvent('error', {
+                    code: 999,
+                    message: 'You can not end others screen sharing!'
+                });
+                return;
+            }
+
+            if(!callUsers['screenShare'].peers[callUsers['screenShare'].videoTopicName]) {
+                consoleLogging && console.log('[SDK][endScreenShare] No screenShare connection available');
+            } else {
+                callStateController.removeScreenShareFromCall();
+            }
+
             return chatMessaging.sendMessage(sendData, {
                 onResult: function (result) {
                     callback && callback(result);
@@ -57854,6 +59410,15 @@ WildEmitter.mixin(WildEmitter);
                     sendMessageParams.content = params.userIds;
                 }
             }
+            callStateController.deactivateParticipantStream(
+                chatMessaging.userInfo.id,
+                'audioTopicName',
+                'mute'
+            )
+/*
+            callStateController.removeTopic(chatMessaging.userInfo.id, callUsers[chatMessaging.userInfo.id].audioTopicName)
+            callStateController.removeStreamFromWebRTC(chatMessaging.userInfo.id, callUsers[chatMessaging.userInfo.id].audioTopicName)
+*/
 
             return chatMessaging.sendMessage(sendMessageParams, {
                 onResult: function (result) {
@@ -57895,6 +59460,26 @@ WildEmitter.mixin(WildEmitter);
                     sendMessageParams.content = params.userIds;
                 }
             }
+            var myId = chatMessaging.userInfo.id;
+
+            callStateController.activateParticipantStream(
+                myId,
+                'audio',
+                'send',
+                'audioTopicName',
+                callUsers[myId].topicSend,
+                'mute'
+            );
+            /*if(callUsers[myId]) {
+                callUsers[myId].mute = false;
+                callUsers[myId].audioTopicName = 'Vo-' + callUsers[myId].topicSend;
+
+                var user = callUsers[myId];
+                callStateController.appendUserToCallDiv(myId, callStateController.generateHTMLElements(myId));
+                setTimeout(function () {
+                    callStateController.createTopic(myId, user.audioTopicName, 'audio', 'send');
+                })
+            }*/
 
             return chatMessaging.sendMessage(sendMessageParams, {
                 onResult: function (result) {
@@ -57908,6 +59493,19 @@ WildEmitter.mixin(WildEmitter);
                         // TODO : What is the result?!
                         var messageContent = result.result;
                         returnData.result = messageContent;
+
+                        /*for(var i in result.result) {
+                            if(callUsers[result.result[i].userId]) {
+                                callUsers[result.result[i].userId].mute = false;
+                                callUsers[result.result[i].userId].audioTopicName = 'Vo-' + result.result[i].sendTopic;
+
+                                var user = callUsers[result.result[i].userId];
+                                callStateController.appendUserToCallDiv(result.result[i].userId, callStateController.generateHTMLElements(result.result[i].userId));
+                                setTimeout(function () {
+                                    callStateController.createTopic(result.result[i].userId, user.audioTopicName, 'audio', 'send');
+                                })
+                            }
+                        }*/
                     }
                     callback && callback(returnData);
                 }
@@ -57942,6 +59540,29 @@ WildEmitter.mixin(WildEmitter);
 
             return chatMessaging.sendMessage(turnOnVideoData, {
                 onResult: function (result) {
+                    if(!result.hasError && Array.isArray(result.result)) {
+                        for(var i in result.result) {
+                            callStateController.activateParticipantStream(
+                                result.result[i].userId,
+                                'video',
+                                'send',
+                                'videoTopicName',
+                                result.result[i].sendTopic,
+                                'video'
+                            );
+                            /*if(callUsers[result.result[i].userId]) {
+                                callUsers[result.result[i].userId].video = true;
+                                callUsers[result.result[i].userId].mute = result.result[i].mute;
+                                callUsers[result.result[i].userId].videoTopicName = 'Vi-' + result.result[i].sendTopic;
+
+                                var user = callUsers[result.result[i].userId];
+                                callStateController.appendUserToCallDiv(result.result[i].userId, callStateController.generateHTMLElements(result.result[i].userId));
+                                setTimeout(function () {
+                                    callStateController.createTopic(result.result[i].userId, user.videoTopicName, 'video', 'send');
+                                })
+                            }*/
+                        }
+                    }
                     callback && callback(result);
                 }
             });
@@ -57973,6 +59594,16 @@ WildEmitter.mixin(WildEmitter);
                 return;
             }
 
+            callStateController.deactivateParticipantStream(
+                chatMessaging.userInfo.id,
+                'videoTopicName',
+                'video'
+            )
+/*
+            callStateController.removeTopic(chatMessaging.userInfo.id, callUsers[chatMessaging.userInfo.id].videoTopicName)
+            callStateController.removeStreamFromWebRTC(chatMessaging.userInfo.id, callUsers[chatMessaging.userInfo.id].videoTopicName)
+*/
+
             return chatMessaging.sendMessage(turnOffVideoData, {
                 onResult: function (result) {
                     callback && callback(result);
@@ -57980,6 +59611,53 @@ WildEmitter.mixin(WildEmitter);
             });
         };
 
+        /**
+         * Pauses camera-send without closing its topic
+         * @param params
+         * @param callback
+         */
+        this.pauseCamera = function (params, callback) {
+            var me = callUsers[chatMessaging.userInfo.id];
+
+            if(!Object.keys(callUsers).length || !me.videoTopicName || !me.peers[me.videoTopicName])
+                return;
+
+            me.peers[me.videoTopicName].getLocalStream().getTracks()[0].enabled = false;
+            callback && callback();
+        };
+
+        this.resumeCamera = function (params, callback) {
+            var me = callUsers[chatMessaging.userInfo.id]
+            if(!Object.keys(callUsers).length || !me.videoTopicName || !me.peers[me.videoTopicName])
+                return;
+
+            me.peers[me.videoTopicName].getLocalStream().getTracks()[0].enabled = true;
+            callback && callback();
+        };
+
+        /**
+         * Pauses mice-send without closing its topic
+         * @param params
+         * @param callback
+         */
+        this.pauseMice = function (params, callback) {
+            var me = callUsers[chatMessaging.userInfo.id];
+            if(!Object.keys(callUsers).length || !me.audioTopicName || !me.peers[me.audioTopicName])
+                return;
+
+            me.peers[me.audioTopicName].getLocalStream().getTracks()[0].enabled = false;
+            callback && callback();
+        };
+
+        this.resumeMice = function (params, callback) {
+            var me = callUsers[chatMessaging.userInfo.id];
+            if(!Object.keys(callUsers).length || !me.audioTopicName || !me.peers[me.audioTopicName])
+                return;
+
+            me.peers[me.audioTopicName].getLocalStream().getTracks()[0].enabled = true;
+            callback && callback();
+        };
+
         this.resizeCallVideo = function (params, callback) {
             if (params) {
                 if (!!params.width && +params.width > 0) {
@@ -57990,13 +59668,19 @@ WildEmitter.mixin(WildEmitter);
                     callVideoMinHeight = +params.height;
                 }
 
-                webpeers[callTopics['sendVideoTopic']].getLocalStream().getTracks()[0].applyConstraints({
+                if(!callUsers[chatMessaging.userInfo.id]){
+                    consoleLogging && console.log("Error in resizeCallVideo(), call not started ");
+                    return;
+                }
+
+                var userObject = callUsers[chatMessaging.userInfo.id]
+                userObject.peers[userObject.videoTopicName].getLocalStream().getTracks()[0].applyConstraints({
                     "width": callVideoMinWidth,
                     "height": callVideoMinHeight
                 })
                     .then((res) => {
-                        uiRemoteMedias[callTopics['sendVideoTopic']].style.width = callVideoMinWidth + 'px';
-                        uiRemoteMedias[callTopics['sendVideoTopic']].style.height = callVideoMinHeight + 'px';
+                        userObject.htmlElements[userObject.videoTopicName].style.width = callVideoMinWidth + 'px';
+                        userObject.htmlElements[userObject.videoTopicName].style.height = callVideoMinHeight + 'px';
                         callback && callback();
                     })
                     .catch((e) => {
@@ -58029,7 +59713,7 @@ WildEmitter.mixin(WildEmitter);
     }
 })();
 
-},{"kurento-utils":297,"webrtc-adapter":317}],330:[function(require,module,exports){
+},{"kurento-utils":298,"webrtc-adapter":318}],331:[function(require,module,exports){
 'use strict';
 
 (function () {
@@ -58222,6 +59906,7 @@ WildEmitter.mixin(WildEmitter);
                 START_SCREEN_SHARE: 123,
                 END_SCREEN_SHARE: 124,
                 DELETE_FROM_CALL_HISTORY: 125,
+                DESTINATED_RECORD_CALL: 126,
                 MUTUAL_GROUPS: 130,
                 CREATE_TAG: 140,
                 EDIT_TAG: 141,
@@ -58230,6 +59915,7 @@ WildEmitter.mixin(WildEmitter);
                 REMOVE_TAG_PARTICIPANT: 144,
                 GET_TAG_LIST: 145,
                 DELETE_MESSAGE_THREAD: 151,
+                EXPORT_CHAT: 152,
                 ERROR: 999
             },
             inviteeVOidTypes = {
@@ -60985,6 +62671,7 @@ WildEmitter.mixin(WildEmitter);
                     case chatMessageVOTypes.TURN_OFF_VIDEO_CALL:
                     case chatMessageVOTypes.ACTIVE_CALL_PARTICIPANTS:
                     case chatMessageVOTypes.CALL_SESSION_CREATED:
+                    case chatMessageVOTypes.DESTINATED_RECORD_CALL:
                         callModule.handleChatMessages(type, chatMessageVOTypes, messageContent, contentCount, threadId, uniqueId);
                         break;
 
@@ -61279,6 +62966,16 @@ WildEmitter.mixin(WildEmitter);
 
                         break;
 
+                    /**
+                     * Type 152    Gives us a json to export for user
+                     */
+                    case chatMessageVOTypes.EXPORT_CHAT:
+                        if (chatMessaging.messagesCallbacks[uniqueId]) {
+                            chatMessaging.messagesCallbacks[uniqueId](Utility.createReturnData(false, '', 0, messageContent, contentCount, uniqueId));
+                        }
+
+                        break;
+
                     /**
                      * Type 999   All unknown errors
                      */
@@ -66695,9 +68392,6 @@ WildEmitter.mixin(WildEmitter);
                 }
             },
 
-
-
-
             /**
              * Delete Cache Database
              *
@@ -67167,6 +68861,8 @@ WildEmitter.mixin(WildEmitter);
                     putInChatWaitQueue(params.message, function () {
                         callback && callback();
                     });
+                } else {
+                    callback && callback();
                 }
             },
 
@@ -67339,7 +69035,7 @@ WildEmitter.mixin(WildEmitter);
                                         callbacks: callbacks
                                     }, function () {
                                         callback && callback();
-                                    });
+                                    }, true);
                                 });
                             break;
                         }
@@ -69410,7 +71106,7 @@ WildEmitter.mixin(WildEmitter);
                 callbacks: callbacks
             }, function () {
                 chatSendQueueHandler();
-            });
+            }, true);
         };
 
         this.deliver = function (params) {
@@ -71525,6 +73221,157 @@ WildEmitter.mixin(WildEmitter);
             removeRoleFromUser(params, callback);
         };
 
+        function requestExportChat(stackArr, wantedCount, stepCount, offset, sendData) {
+            sendData.content.offset = offset;
+            sendData.content.count = stepCount;
+            return new Promise(function(resolve, reject){
+                return chatMessaging.sendMessage(sendData, {
+                    onResult: function (result) {
+                        var returnData = {
+                            hasError: result.hasError,
+                            cache: false,
+                            errorMessage: result.errorMessage,
+                            errorCode: result.errorCode
+                        };
+
+                        if (!returnData.hasError) {
+                            for(var i in result.result) {
+                                stackArr.push(result.result[i]);
+                            }
+
+                            consoleLogging && console.log("[SDK][exportChat] a step passed...");
+                            wantedCount = wantedCount > result.contentCount ? result.contentCount : wantedCount;
+                            setTimeout(function () {
+                                chatEvents.fireEvent('threadEvents', {
+                                    type: 'EXPORT_CHAT',
+                                    subType: 'IN_PROGRESS',
+                                    threadId: sendData.subjectId,
+                                    percent: Math.floor((stackArr.length / wantedCount) * 100)
+                                });
+
+                                if(stackArr.length < wantedCount) {
+                                    stepCount = wantedCount - stackArr.length < stepCount ? wantedCount - stackArr.length : stepCount;
+                                    resolve(requestExportChat(stackArr, wantedCount, stepCount, stackArr.length, sendData));
+                                } else {
+                                    resolve(stackArr);
+                                }
+                            });
+                            /*returnData.result = result;*/
+                            /*var messageContent = result.result,
+                                messageLength = messageContent.length,
+                                resultData = {
+                                    participants: formatDataToMakeAssistantHistoryList(messageContent),
+                                    contentCount: result.contentCount,
+                                    hasNext: (sendData.content.offset + sendData.content.count < result.contentCount && messageLength > 0),
+                                    nextOffset: sendData.content.offset * 1 + messageLength * 1
+                                };
+
+                            returnData.result = resultData;*/
+                        } else {
+                            consoleLogging && console.log("[SDK][exportChat] Problem in one step... . Rerunning the request.", wantedCount, stepCount, stackArr.length, sendData, result);
+                            resolve(requestExportChat(stackArr, wantedCount, stepCount, stackArr.length, sendData))
+                        }
+                    }
+                });
+            })
+        }
+
+        this.exportChat = function (params, callback) {
+            var stackArr = [], wantedCount = 10000, stepCount = 500, offset = 0;
+            var sendData = {
+                chatMessageVOType: chatMessageVOTypes.EXPORT_CHAT,
+                typeCode: params.typeCode,
+                content: {
+                    offset: +params.offset > 0 ? +params.offset : offset,
+                    count: +params.count > 0 ? +params.count : wantedCount,//config.getHistoryCount,
+                },
+                subjectId: params.threadId
+            };
+
+            if (+params.fromTime > 0 && +params.fromTime < 9999999999999) {
+                sendData.content.fromTime = +params.fromTime;
+            }
+
+            if (+params.toTime > 0 && +params.toTime < 9999999999999) {
+                sendData.content.toTime = +params.toTime;
+            }
+
+            if(+params.wantedCount > 0) {
+                wantedCount = params.wantedCount;
+            }
+
+            if(+params.stepCount > 0) {
+                stepCount = params.stepCount;
+            }
+
+            if(+params.offset > 0) {
+                offset = params.offset;
+            }
+
+            if (params.messageType && typeof params.messageType.toUpperCase() !== 'undefined' && chatMessageTypes[params.messageType.toUpperCase()] > 0) {
+                sendData.content.messageType = chatMessageTypes[params.messageType.toUpperCase()];
+            }
+
+            if(wantedCount < stepCount)
+                stepCount = wantedCount;
+
+            consoleLogging && console.log("[SDK][exportChat] Starting...");
+            requestExportChat(stackArr, wantedCount, stepCount, offset, sendData).then(function (result) {
+                consoleLogging && console.log("[SDK][exportChat] Export done..., Now converting...");
+
+                var exportedFilename = 'export-' + params.threadId + '.csv',
+                    responseType = params.responseType !== null ? params.responseType : "blob",
+                    autoStartDownload = params.autoStartDownload !== null ? params.autoStartDownload : true
+
+                var blob = new Blob([Utility.convertToCSV(result)], { type: 'text/csv;charset=utf-8;' });
+                chatEvents.fireEvent('threadEvents', {
+                    type: 'EXPORT_CHAT',
+                    subType: 'DONE',
+                    threadId: sendData.subjectId,
+                    result: blob
+                });
+
+                /*if (navigator.msSaveBlob) { // IE 10+
+                    if(params.autoStartDownload) {
+                        navigator.msSaveBlob(blob, exportedFilename);
+                    }
+                    callback && callback({
+                        hasError: false,
+                        type: 'blob',
+                        result: blob
+                    });
+                } else {*/
+                if(responseType === 'link') {
+                    var link = document.createElement("a"),
+                        url = URL.createObjectURL(blob);
+                    //if (link.download !== undefined) { // feature detection
+                        // Browsers that support HTML5 download attribute
+                    link.setAttribute("href", url);
+                    link.setAttribute("download", exportedFilename);
+                    if(autoStartDownload) {
+                        link.style.visibility = 'hidden';
+                        document.body.appendChild(link);
+                        link.click();
+                        document.body.removeChild(link);
+                    }
+                    //}
+                    callback && callback({
+                        hasError: false,
+                        type: 'link',
+                        result: link
+                    });
+                } else {
+                    callback && callback({
+                        hasError: false,
+                        type: 'blob',
+                        result: blob
+                    });
+                }
+                //}
+                callback = undefined;
+            });
+        }
+
         this.startCall = callModule.startCall;
 
         this.startGroupCall = callModule.startGroupCall;
@@ -71565,6 +73412,14 @@ WildEmitter.mixin(WildEmitter);
 
         this.turnOffVideoCall = callModule.turnOffVideoCall;
 
+        this.pauseCamera = callModule.pauseCamera;
+
+        this.resumeCamera = callModule.resumeCamera;
+
+        this.pauseMice = callModule.pauseMice;
+
+        this.resumeMice = callModule.resumeMice;
+
         this.resizeCallVideo = callModule.resizeCallVideo;
 
         this.restartMedia = callModule.restartMedia;
@@ -71807,7 +73662,7 @@ WildEmitter.mixin(WildEmitter);
     }
 })();
 
-},{"./call.module.js":329,"./events.module.js":331,"./messaging.module.js":332,"./utility/utility.js":333,"@sentry/browser":194,"dexie":288,"podasync-ws-only":300}],331:[function(require,module,exports){
+},{"./call.module.js":330,"./events.module.js":332,"./messaging.module.js":333,"./utility/utility.js":334,"@sentry/browser":194,"dexie":288,"podasync-ws-only":301}],332:[function(require,module,exports){
 (function () {
     /**
      * Global Variables
@@ -71817,6 +73672,7 @@ WildEmitter.mixin(WildEmitter);
         //if (typeof (require) !== 'undefined' && typeof (exports) !== 'undefined') {} else {}
 
         var Sentry = params.Sentry,
+            currentModuleInstance = this,
             Utility = params.Utility,
             consoleLogging = params.consoleLogging,
             token = params.token,
@@ -71928,11 +73784,12 @@ WildEmitter.mixin(WildEmitter);
     }
 })();
 
-},{}],332:[function(require,module,exports){
+},{}],333:[function(require,module,exports){
 (function () {
     /**
      * Global Variables
      */
+    var DOMPurify;
 
     /**
      * Communicates with chat server
@@ -71940,7 +73797,11 @@ WildEmitter.mixin(WildEmitter);
      * @constructor
      */
     function ChatMessaging(params) {
-        //if (typeof (require) !== 'undefined' && typeof (exports) !== 'undefined') {} else {}
+        if (typeof (require) !== 'undefined' && typeof (exports) !== 'undefined') {
+            DOMPurify = require('dompurify');
+        } else {
+            DOMPurify = window.DOMPurify;
+        }
 
         var currentModuleInstance = this,
             asyncClient = params.asyncClient,
@@ -72043,6 +73904,9 @@ WildEmitter.mixin(WildEmitter);
                     messageVO.content = JSON.stringify(params.content);
                 } else {
                     messageVO.content = params.content;
+                    if(DOMPurify.isSupported) {
+                        messageVO.content = DOMPurify.sanitize(messageVO.content, {ALLOWED_TAGS: []});
+                    }
                 }
             }
 
@@ -72232,7 +74096,7 @@ WildEmitter.mixin(WildEmitter);
     }
 })();
 
-},{}],333:[function(require,module,exports){
+},{"dompurify":289}],334:[function(require,module,exports){
 (function (global){(function (){
 (function() {
 
@@ -72781,6 +74645,31 @@ WildEmitter.mixin(WildEmitter);
                 console.log("Error happened at Utility.jsonParser function()", e);
             }
         };
+
+        /**
+         * Export given json to csv
+         *
+         * @param objArray
+         * @return {string}
+         */
+        this.convertToCSV = function(objArray) {
+            var array = typeof objArray != 'object' ? JSON.parse(objArray) : objArray;
+            var str = '';
+
+            for (var i = 0; i < array.length; i++) {
+                var line = '';
+                for (var index in array[i]) {
+                    if (line != '') line += ','
+
+                    line += index;
+                    line += ": " + (typeof array[i][index] !== 'string' ?  JSON.stringify(array[i][index]).replaceAll(",", ".") : array[i][index]);
+                }
+
+                str += line + '\r\n';
+            }
+
+            return str;
+        }
     }
 
     if (typeof module !== 'undefined' && typeof module.exports != 'undefined') {