@vonage/ml-transformers 1.0.1

package/dist/ml-transformers.es.js

@@ -0,0 +1,1254 @@
+function isSupported$1() {
+  return new Promise((resolve, reject) => {
+    if (typeof MediaStreamTrackProcessor === "undefined" || typeof MediaStreamTrackGenerator === "undefined") {
+      reject("Your browser does not support the MediaStreamTrack API for Insertable Streams of Media.");
+    } else {
+      resolve();
+    }
+  });
+}
+var axios$2 = { exports: {} };
+var bind$2 = function bind(fn, thisArg) {
+  return function wrap() {
+    var args = new Array(arguments.length);
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
+    }
+    return fn.apply(thisArg, args);
+  };
+};
+var bind$1 = bind$2;
+var toString = Object.prototype.toString;
+function isArray(val) {
+  return Array.isArray(val);
+}
+function isUndefined(val) {
+  return typeof val === "undefined";
+}
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+}
+function isArrayBuffer(val) {
+  return toString.call(val) === "[object ArrayBuffer]";
+}
+function isFormData(val) {
+  return toString.call(val) === "[object FormData]";
+}
+function isArrayBufferView(val) {
+  var result;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+    result = ArrayBuffer.isView(val);
+  } else {
+    result = val && val.buffer && isArrayBuffer(val.buffer);
+  }
+  return result;
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isObject(val) {
+  return val !== null && typeof val === "object";
+}
+function isPlainObject(val) {
+  if (toString.call(val) !== "[object Object]") {
+    return false;
+  }
+  var prototype = Object.getPrototypeOf(val);
+  return prototype === null || prototype === Object.prototype;
+}
+function isDate(val) {
+  return toString.call(val) === "[object Date]";
+}
+function isFile(val) {
+  return toString.call(val) === "[object File]";
+}
+function isBlob(val) {
+  return toString.call(val) === "[object Blob]";
+}
+function isFunction(val) {
+  return toString.call(val) === "[object Function]";
+}
+function isStream(val) {
+  return isObject(val) && isFunction(val.pipe);
+}
+function isURLSearchParams(val) {
+  return toString.call(val) === "[object URLSearchParams]";
+}
+function trim(str) {
+  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+}
+function isStandardBrowserEnv() {
+  if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+    return false;
+  }
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function forEach(obj, fn) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray(obj)) {
+    for (var i = 0, l = obj.length; i < l; i++) {
+      fn.call(null, obj[i], i, obj);
+    }
+  } else {
+    for (var key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        fn.call(null, obj[key], key, obj);
+      }
+    }
+  }
+}
+function merge() {
+  var result = {};
+  function assignValue(val, key) {
+    if (isPlainObject(result[key]) && isPlainObject(val)) {
+      result[key] = merge(result[key], val);
+    } else if (isPlainObject(val)) {
+      result[key] = merge({}, val);
+    } else if (isArray(val)) {
+      result[key] = val.slice();
+    } else {
+      result[key] = val;
+    }
+  }
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    forEach(arguments[i], assignValue);
+  }
+  return result;
+}
+function extend(a, b, thisArg) {
+  forEach(b, function assignValue(val, key) {
+    if (thisArg && typeof val === "function") {
+      a[key] = bind$1(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  });
+  return a;
+}
+function stripBOM(content) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+}
+var utils$e = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isStandardBrowserEnv,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM
+};
+var utils$d = utils$e;
+function encode(val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+var buildURL$2 = function buildURL(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (utils$d.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    utils$d.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (utils$d.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      utils$d.forEach(val, function parseValue(v) {
+        if (utils$d.isDate(v)) {
+          v = v.toISOString();
+        } else if (utils$d.isObject(v)) {
+          v = JSON.stringify(v);
+        }
+        parts.push(encode(key) + "=" + encode(v));
+      });
+    });
+    serializedParams = parts.join("&");
+  }
+  if (serializedParams) {
+    var hashmarkIndex = url.indexOf("#");
+    if (hashmarkIndex !== -1) {
+      url = url.slice(0, hashmarkIndex);
+    }
+    url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+  }
+  return url;
+};
+var utils$c = utils$e;
+function InterceptorManager$1() {
+  this.handlers = [];
+}
+InterceptorManager$1.prototype.use = function use(fulfilled, rejected, options) {
+  this.handlers.push({
+    fulfilled,
+    rejected,
+    synchronous: options ? options.synchronous : false,
+    runWhen: options ? options.runWhen : null
+  });
+  return this.handlers.length - 1;
+};
+InterceptorManager$1.prototype.eject = function eject(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager$1.prototype.forEach = function forEach2(fn) {
+  utils$c.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+var InterceptorManager_1 = InterceptorManager$1;
+var utils$b = utils$e;
+var normalizeHeaderName$1 = function normalizeHeaderName(headers, normalizedName) {
+  utils$b.forEach(headers, function processHeader(value, name) {
+    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+      headers[normalizedName] = value;
+      delete headers[name];
+    }
+  });
+};
+var enhanceError$2 = function enhanceError(error, config, code, request2, response) {
+  error.config = config;
+  if (code) {
+    error.code = code;
+  }
+  error.request = request2;
+  error.response = response;
+  error.isAxiosError = true;
+  error.toJSON = function toJSON() {
+    return {
+      message: this.message,
+      name: this.name,
+      description: this.description,
+      number: this.number,
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      config: this.config,
+      code: this.code,
+      status: this.response && this.response.status ? this.response.status : null
+    };
+  };
+  return error;
+};
+var enhanceError$1 = enhanceError$2;
+var createError$2 = function createError(message, config, code, request2, response) {
+  var error = new Error(message);
+  return enhanceError$1(error, config, code, request2, response);
+};
+var createError$1 = createError$2;
+var settle$1 = function settle(resolve, reject, response) {
+  var validateStatus2 = response.config.validateStatus;
+  if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
+    resolve(response);
+  } else {
+    reject(createError$1("Request failed with status code " + response.status, response.config, null, response.request, response));
+  }
+};
+var utils$a = utils$e;
+var cookies$1 = utils$a.isStandardBrowserEnv() ? function standardBrowserEnv() {
+  return {
+    write: function write(name, value, expires, path, domain, secure) {
+      var cookie = [];
+      cookie.push(name + "=" + encodeURIComponent(value));
+      if (utils$a.isNumber(expires)) {
+        cookie.push("expires=" + new Date(expires).toGMTString());
+      }
+      if (utils$a.isString(path)) {
+        cookie.push("path=" + path);
+      }
+      if (utils$a.isString(domain)) {
+        cookie.push("domain=" + domain);
+      }
+      if (secure === true) {
+        cookie.push("secure");
+      }
+      document.cookie = cookie.join("; ");
+    },
+    read: function read(name) {
+      var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
+      return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove: function remove(name) {
+      this.write(name, "", Date.now() - 864e5);
+    }
+  };
+}() : function nonStandardBrowserEnv() {
+  return {
+    write: function write() {
+    },
+    read: function read() {
+      return null;
+    },
+    remove: function remove() {
+    }
+  };
+}();
+var isAbsoluteURL$1 = function isAbsoluteURL(url) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+};
+var combineURLs$1 = function combineURLs(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+};
+var isAbsoluteURL2 = isAbsoluteURL$1;
+var combineURLs2 = combineURLs$1;
+var buildFullPath$1 = function buildFullPath(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL2(requestedURL)) {
+    return combineURLs2(baseURL, requestedURL);
+  }
+  return requestedURL;
+};
+var utils$9 = utils$e;
+var ignoreDuplicateOf = [
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "user-agent"
+];
+var parseHeaders$1 = function parseHeaders(headers) {
+  var parsed = {};
+  var key;
+  var val;
+  var i;
+  if (!headers) {
+    return parsed;
+  }
+  utils$9.forEach(headers.split("\n"), function parser(line) {
+    i = line.indexOf(":");
+    key = utils$9.trim(line.substr(0, i)).toLowerCase();
+    val = utils$9.trim(line.substr(i + 1));
+    if (key) {
+      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+        return;
+      }
+      if (key === "set-cookie") {
+        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+      } else {
+        parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+      }
+    }
+  });
+  return parsed;
+};
+var utils$8 = utils$e;
+var isURLSameOrigin$1 = utils$8.isStandardBrowserEnv() ? function standardBrowserEnv2() {
+  var msie = /(msie|trident)/i.test(navigator.userAgent);
+  var urlParsingNode = document.createElement("a");
+  var originURL;
+  function resolveURL(url) {
+    var href = url;
+    if (msie) {
+      urlParsingNode.setAttribute("href", href);
+      href = urlParsingNode.href;
+    }
+    urlParsingNode.setAttribute("href", href);
+    return {
+      href: urlParsingNode.href,
+      protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
+      host: urlParsingNode.host,
+      search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
+      hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
+      hostname: urlParsingNode.hostname,
+      port: urlParsingNode.port,
+      pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
+    };
+  }
+  originURL = resolveURL(window.location.href);
+  return function isURLSameOrigin2(requestURL) {
+    var parsed = utils$8.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+    return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+  };
+}() : function nonStandardBrowserEnv2() {
+  return function isURLSameOrigin2() {
+    return true;
+  };
+}();
+function Cancel$3(message) {
+  this.message = message;
+}
+Cancel$3.prototype.toString = function toString2() {
+  return "Cancel" + (this.message ? ": " + this.message : "");
+};
+Cancel$3.prototype.__CANCEL__ = true;
+var Cancel_1 = Cancel$3;
+var utils$7 = utils$e;
+var settle2 = settle$1;
+var cookies = cookies$1;
+var buildURL$1 = buildURL$2;
+var buildFullPath2 = buildFullPath$1;
+var parseHeaders2 = parseHeaders$1;
+var isURLSameOrigin = isURLSameOrigin$1;
+var createError2 = createError$2;
+var defaults$4 = defaults_1;
+var Cancel$2 = Cancel_1;
+var xhr = function xhrAdapter(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    var requestData = config.data;
+    var requestHeaders = config.headers;
+    var responseType = config.responseType;
+    var onCanceled;
+    function done() {
+      if (config.cancelToken) {
+        config.cancelToken.unsubscribe(onCanceled);
+      }
+      if (config.signal) {
+        config.signal.removeEventListener("abort", onCanceled);
+      }
+    }
+    if (utils$7.isFormData(requestData)) {
+      delete requestHeaders["Content-Type"];
+    }
+    var request2 = new XMLHttpRequest();
+    if (config.auth) {
+      var username = config.auth.username || "";
+      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
+      requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
+    }
+    var fullPath = buildFullPath2(config.baseURL, config.url);
+    request2.open(config.method.toUpperCase(), buildURL$1(fullPath, config.params, config.paramsSerializer), true);
+    request2.timeout = config.timeout;
+    function onloadend() {
+      if (!request2) {
+        return;
+      }
+      var responseHeaders = "getAllResponseHeaders" in request2 ? parseHeaders2(request2.getAllResponseHeaders()) : null;
+      var responseData = !responseType || responseType === "text" || responseType === "json" ? request2.responseText : request2.response;
+      var response = {
+        data: responseData,
+        status: request2.status,
+        statusText: request2.statusText,
+        headers: responseHeaders,
+        config,
+        request: request2
+      };
+      settle2(function _resolve(value) {
+        resolve(value);
+        done();
+      }, function _reject(err) {
+        reject(err);
+        done();
+      }, response);
+      request2 = null;
+    }
+    if ("onloadend" in request2) {
+      request2.onloadend = onloadend;
+    } else {
+      request2.onreadystatechange = function handleLoad() {
+        if (!request2 || request2.readyState !== 4) {
+          return;
+        }
+        if (request2.status === 0 && !(request2.responseURL && request2.responseURL.indexOf("file:") === 0)) {
+          return;
+        }
+        setTimeout(onloadend);
+      };
+    }
+    request2.onabort = function handleAbort() {
+      if (!request2) {
+        return;
+      }
+      reject(createError2("Request aborted", config, "ECONNABORTED", request2));
+      request2 = null;
+    };
+    request2.onerror = function handleError() {
+      reject(createError2("Network Error", config, null, request2));
+      request2 = null;
+    };
+    request2.ontimeout = function handleTimeout() {
+      var timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
+      var transitional2 = config.transitional || defaults$4.transitional;
+      if (config.timeoutErrorMessage) {
+        timeoutErrorMessage = config.timeoutErrorMessage;
+      }
+      reject(createError2(timeoutErrorMessage, config, transitional2.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", request2));
+      request2 = null;
+    };
+    if (utils$7.isStandardBrowserEnv()) {
+      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
+      if (xsrfValue) {
+        requestHeaders[config.xsrfHeaderName] = xsrfValue;
+      }
+    }
+    if ("setRequestHeader" in request2) {
+      utils$7.forEach(requestHeaders, function setRequestHeader(val, key) {
+        if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+          delete requestHeaders[key];
+        } else {
+          request2.setRequestHeader(key, val);
+        }
+      });
+    }
+    if (!utils$7.isUndefined(config.withCredentials)) {
+      request2.withCredentials = !!config.withCredentials;
+    }
+    if (responseType && responseType !== "json") {
+      request2.responseType = config.responseType;
+    }
+    if (typeof config.onDownloadProgress === "function") {
+      request2.addEventListener("progress", config.onDownloadProgress);
+    }
+    if (typeof config.onUploadProgress === "function" && request2.upload) {
+      request2.upload.addEventListener("progress", config.onUploadProgress);
+    }
+    if (config.cancelToken || config.signal) {
+      onCanceled = function(cancel) {
+        if (!request2) {
+          return;
+        }
+        reject(!cancel || cancel && cancel.type ? new Cancel$2("canceled") : cancel);
+        request2.abort();
+        request2 = null;
+      };
+      config.cancelToken && config.cancelToken.subscribe(onCanceled);
+      if (config.signal) {
+        config.signal.aborted ? onCanceled() : config.signal.addEventListener("abort", onCanceled);
+      }
+    }
+    if (!requestData) {
+      requestData = null;
+    }
+    request2.send(requestData);
+  });
+};
+var utils$6 = utils$e;
+var normalizeHeaderName2 = normalizeHeaderName$1;
+var enhanceError2 = enhanceError$2;
+var DEFAULT_CONTENT_TYPE = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function setContentTypeIfUnset(headers, value) {
+  if (!utils$6.isUndefined(headers) && utils$6.isUndefined(headers["Content-Type"])) {
+    headers["Content-Type"] = value;
+  }
+}
+function getDefaultAdapter() {
+  var adapter;
+  if (typeof XMLHttpRequest !== "undefined") {
+    adapter = xhr;
+  } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+    adapter = xhr;
+  }
+  return adapter;
+}
+function stringifySafely(rawValue, parser, encoder) {
+  if (utils$6.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils$6.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError") {
+        throw e;
+      }
+    }
+  }
+  return (encoder || JSON.stringify)(rawValue);
+}
+var defaults$3 = {
+  transitional: {
+    silentJSONParsing: true,
+    forcedJSONParsing: true,
+    clarifyTimeoutError: false
+  },
+  adapter: getDefaultAdapter(),
+  transformRequest: [function transformRequest(data2, headers) {
+    normalizeHeaderName2(headers, "Accept");
+    normalizeHeaderName2(headers, "Content-Type");
+    if (utils$6.isFormData(data2) || utils$6.isArrayBuffer(data2) || utils$6.isBuffer(data2) || utils$6.isStream(data2) || utils$6.isFile(data2) || utils$6.isBlob(data2)) {
+      return data2;
+    }
+    if (utils$6.isArrayBufferView(data2)) {
+      return data2.buffer;
+    }
+    if (utils$6.isURLSearchParams(data2)) {
+      setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+      return data2.toString();
+    }
+    if (utils$6.isObject(data2) || headers && headers["Content-Type"] === "application/json") {
+      setContentTypeIfUnset(headers, "application/json");
+      return stringifySafely(data2);
+    }
+    return data2;
+  }],
+  transformResponse: [function transformResponse(data2) {
+    var transitional2 = this.transitional || defaults$3.transitional;
+    var silentJSONParsing = transitional2 && transitional2.silentJSONParsing;
+    var forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing;
+    var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+    if (strictJSONParsing || forcedJSONParsing && utils$6.isString(data2) && data2.length) {
+      try {
+        return JSON.parse(data2);
+      } catch (e) {
+        if (strictJSONParsing) {
+          if (e.name === "SyntaxError") {
+            throw enhanceError2(e, this, "E_JSON_PARSE");
+          }
+          throw e;
+        }
+      }
+    }
+    return data2;
+  }],
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  },
+  headers: {
+    common: {
+      "Accept": "application/json, text/plain, */*"
+    }
+  }
+};
+utils$6.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+  defaults$3.headers[method] = {};
+});
+utils$6.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+  defaults$3.headers[method] = utils$6.merge(DEFAULT_CONTENT_TYPE);
+});
+var defaults_1 = defaults$3;
+var utils$5 = utils$e;
+var defaults$2 = defaults_1;
+var transformData$1 = function transformData(data2, headers, fns) {
+  var context = this || defaults$2;
+  utils$5.forEach(fns, function transform(fn) {
+    data2 = fn.call(context, data2, headers);
+  });
+  return data2;
+};
+var isCancel$1 = function isCancel(value) {
+  return !!(value && value.__CANCEL__);
+};
+var utils$4 = utils$e;
+var transformData2 = transformData$1;
+var isCancel2 = isCancel$1;
+var defaults$1 = defaults_1;
+var Cancel$1 = Cancel_1;
+function throwIfCancellationRequested(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
+  }
+  if (config.signal && config.signal.aborted) {
+    throw new Cancel$1("canceled");
+  }
+}
+var dispatchRequest$1 = function dispatchRequest(config) {
+  throwIfCancellationRequested(config);
+  config.headers = config.headers || {};
+  config.data = transformData2.call(config, config.data, config.headers, config.transformRequest);
+  config.headers = utils$4.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
+  utils$4.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) {
+    delete config.headers[method];
+  });
+  var adapter = config.adapter || defaults$1.adapter;
+  return adapter(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config);
+    response.data = transformData2.call(config, response.data, response.headers, config.transformResponse);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel2(reason)) {
+      throwIfCancellationRequested(config);
+      if (reason && reason.response) {
+        reason.response.data = transformData2.call(config, reason.response.data, reason.response.headers, config.transformResponse);
+      }
+    }
+    return Promise.reject(reason);
+  });
+};
+var utils$3 = utils$e;
+var mergeConfig$2 = function mergeConfig(config1, config2) {
+  config2 = config2 || {};
+  var config = {};
+  function getMergedValue(target, source2) {
+    if (utils$3.isPlainObject(target) && utils$3.isPlainObject(source2)) {
+      return utils$3.merge(target, source2);
+    } else if (utils$3.isPlainObject(source2)) {
+      return utils$3.merge({}, source2);
+    } else if (utils$3.isArray(source2)) {
+      return source2.slice();
+    }
+    return source2;
+  }
+  function mergeDeepProperties(prop) {
+    if (!utils$3.isUndefined(config2[prop])) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (!utils$3.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function valueFromConfig2(prop) {
+    if (!utils$3.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    }
+  }
+  function defaultToConfig2(prop) {
+    if (!utils$3.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    } else if (!utils$3.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function mergeDirectKeys(prop) {
+    if (prop in config2) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (prop in config1) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  var mergeMap = {
+    "url": valueFromConfig2,
+    "method": valueFromConfig2,
+    "data": valueFromConfig2,
+    "baseURL": defaultToConfig2,
+    "transformRequest": defaultToConfig2,
+    "transformResponse": defaultToConfig2,
+    "paramsSerializer": defaultToConfig2,
+    "timeout": defaultToConfig2,
+    "timeoutMessage": defaultToConfig2,
+    "withCredentials": defaultToConfig2,
+    "adapter": defaultToConfig2,
+    "responseType": defaultToConfig2,
+    "xsrfCookieName": defaultToConfig2,
+    "xsrfHeaderName": defaultToConfig2,
+    "onUploadProgress": defaultToConfig2,
+    "onDownloadProgress": defaultToConfig2,
+    "decompress": defaultToConfig2,
+    "maxContentLength": defaultToConfig2,
+    "maxBodyLength": defaultToConfig2,
+    "transport": defaultToConfig2,
+    "httpAgent": defaultToConfig2,
+    "httpsAgent": defaultToConfig2,
+    "cancelToken": defaultToConfig2,
+    "socketPath": defaultToConfig2,
+    "responseEncoding": defaultToConfig2,
+    "validateStatus": mergeDirectKeys
+  };
+  utils$3.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
+    var merge2 = mergeMap[prop] || mergeDeepProperties;
+    var configValue = merge2(prop);
+    utils$3.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
+  });
+  return config;
+};
+var data = {
+  "version": "0.25.0"
+};
+var VERSION = data.version;
+var validators$1 = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+  validators$1[type] = function validator2(thing) {
+    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+  };
+});
+var deprecatedWarnings = {};
+validators$1.transitional = function transitional(validator2, version2, message) {
+  function formatMessage(opt, desc) {
+    return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+  }
+  return function(value, opt, opts) {
+    if (validator2 === false) {
+      throw new Error(formatMessage(opt, " has been removed" + (version2 ? " in " + version2 : "")));
+    }
+    if (version2 && !deprecatedWarnings[opt]) {
+      deprecatedWarnings[opt] = true;
+      console.warn(formatMessage(opt, " has been deprecated since v" + version2 + " and will be removed in the near future"));
+    }
+    return validator2 ? validator2(value, opt, opts) : true;
+  };
+};
+function assertOptions(options, schema, allowUnknown) {
+  if (typeof options !== "object") {
+    throw new TypeError("options must be an object");
+  }
+  var keys = Object.keys(options);
+  var i = keys.length;
+  while (i-- > 0) {
+    var opt = keys[i];
+    var validator2 = schema[opt];
+    if (validator2) {
+      var value = options[opt];
+      var result = value === void 0 || validator2(value, opt, options);
+      if (result !== true) {
+        throw new TypeError("option " + opt + " must be " + result);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw Error("Unknown option " + opt);
+    }
+  }
+}
+var validator$1 = {
+  assertOptions,
+  validators: validators$1
+};
+var utils$2 = utils$e;
+var buildURL2 = buildURL$2;
+var InterceptorManager = InterceptorManager_1;
+var dispatchRequest2 = dispatchRequest$1;
+var mergeConfig$1 = mergeConfig$2;
+var validator = validator$1;
+var validators = validator.validators;
+function Axios$1(instanceConfig) {
+  this.defaults = instanceConfig;
+  this.interceptors = {
+    request: new InterceptorManager(),
+    response: new InterceptorManager()
+  };
+}
+Axios$1.prototype.request = function request(configOrUrl, config) {
+  if (typeof configOrUrl === "string") {
+    config = config || {};
+    config.url = configOrUrl;
+  } else {
+    config = configOrUrl || {};
+  }
+  if (!config.url) {
+    throw new Error("Provided config url is not valid");
+  }
+  config = mergeConfig$1(this.defaults, config);
+  if (config.method) {
+    config.method = config.method.toLowerCase();
+  } else if (this.defaults.method) {
+    config.method = this.defaults.method.toLowerCase();
+  } else {
+    config.method = "get";
+  }
+  var transitional2 = config.transitional;
+  if (transitional2 !== void 0) {
+    validator.assertOptions(transitional2, {
+      silentJSONParsing: validators.transitional(validators.boolean),
+      forcedJSONParsing: validators.transitional(validators.boolean),
+      clarifyTimeoutError: validators.transitional(validators.boolean)
+    }, false);
+  }
+  var requestInterceptorChain = [];
+  var synchronousRequestInterceptors = true;
+  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+    if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
+      return;
+    }
+    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+  });
+  var responseInterceptorChain = [];
+  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+  });
+  var promise;
+  if (!synchronousRequestInterceptors) {
+    var chain = [dispatchRequest2, void 0];
+    Array.prototype.unshift.apply(chain, requestInterceptorChain);
+    chain = chain.concat(responseInterceptorChain);
+    promise = Promise.resolve(config);
+    while (chain.length) {
+      promise = promise.then(chain.shift(), chain.shift());
+    }
+    return promise;
+  }
+  var newConfig = config;
+  while (requestInterceptorChain.length) {
+    var onFulfilled = requestInterceptorChain.shift();
+    var onRejected = requestInterceptorChain.shift();
+    try {
+      newConfig = onFulfilled(newConfig);
+    } catch (error) {
+      onRejected(error);
+      break;
+    }
+  }
+  try {
+    promise = dispatchRequest2(newConfig);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  while (responseInterceptorChain.length) {
+    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+  }
+  return promise;
+};
+Axios$1.prototype.getUri = function getUri(config) {
+  if (!config.url) {
+    throw new Error("Provided config url is not valid");
+  }
+  config = mergeConfig$1(this.defaults, config);
+  return buildURL2(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
+};
+utils$2.forEach(["delete", "get", "head", "options"], function forEachMethodNoData2(method) {
+  Axios$1.prototype[method] = function(url, config) {
+    return this.request(mergeConfig$1(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+utils$2.forEach(["post", "put", "patch"], function forEachMethodWithData2(method) {
+  Axios$1.prototype[method] = function(url, data2, config) {
+    return this.request(mergeConfig$1(config || {}, {
+      method,
+      url,
+      data: data2
+    }));
+  };
+});
+var Axios_1 = Axios$1;
+var Cancel = Cancel_1;
+function CancelToken(executor) {
+  if (typeof executor !== "function") {
+    throw new TypeError("executor must be a function.");
+  }
+  var resolvePromise;
+  this.promise = new Promise(function promiseExecutor(resolve) {
+    resolvePromise = resolve;
+  });
+  var token = this;
+  this.promise.then(function(cancel) {
+    if (!token._listeners)
+      return;
+    var i;
+    var l = token._listeners.length;
+    for (i = 0; i < l; i++) {
+      token._listeners[i](cancel);
+    }
+    token._listeners = null;
+  });
+  this.promise.then = function(onfulfilled) {
+    var _resolve;
+    var promise = new Promise(function(resolve) {
+      token.subscribe(resolve);
+      _resolve = resolve;
+    }).then(onfulfilled);
+    promise.cancel = function reject() {
+      token.unsubscribe(_resolve);
+    };
+    return promise;
+  };
+  executor(function cancel(message) {
+    if (token.reason) {
+      return;
+    }
+    token.reason = new Cancel(message);
+    resolvePromise(token.reason);
+  });
+}
+CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+  if (this.reason) {
+    throw this.reason;
+  }
+};
+CancelToken.prototype.subscribe = function subscribe(listener) {
+  if (this.reason) {
+    listener(this.reason);
+    return;
+  }
+  if (this._listeners) {
+    this._listeners.push(listener);
+  } else {
+    this._listeners = [listener];
+  }
+};
+CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
+  if (!this._listeners) {
+    return;
+  }
+  var index = this._listeners.indexOf(listener);
+  if (index !== -1) {
+    this._listeners.splice(index, 1);
+  }
+};
+CancelToken.source = function source() {
+  var cancel;
+  var token = new CancelToken(function executor(c) {
+    cancel = c;
+  });
+  return {
+    token,
+    cancel
+  };
+};
+var CancelToken_1 = CancelToken;
+var spread = function spread2(callback) {
+  return function wrap(arr) {
+    return callback.apply(null, arr);
+  };
+};
+var utils$1 = utils$e;
+var isAxiosError = function isAxiosError2(payload) {
+  return utils$1.isObject(payload) && payload.isAxiosError === true;
+};
+var utils = utils$e;
+var bind2 = bind$2;
+var Axios = Axios_1;
+var mergeConfig2 = mergeConfig$2;
+var defaults = defaults_1;
+function createInstance(defaultConfig) {
+  var context = new Axios(defaultConfig);
+  var instance = bind2(Axios.prototype.request, context);
+  utils.extend(instance, Axios.prototype, context);
+  utils.extend(instance, context);
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig2(defaultConfig, instanceConfig));
+  };
+  return instance;
+}
+var axios$1 = createInstance(defaults);
+axios$1.Axios = Axios;
+axios$1.Cancel = Cancel_1;
+axios$1.CancelToken = CancelToken_1;
+axios$1.isCancel = isCancel$1;
+axios$1.VERSION = data.version;
+axios$1.all = function all(promises) {
+  return Promise.all(promises);
+};
+axios$1.spread = spread;
+axios$1.isAxiosError = isAxiosError;
+axios$2.exports = axios$1;
+axios$2.exports.default = axios$1;
+var byteToHex = [];
+for (var i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).substr(1));
+}
+class InsertableStreamHelper {
+  constructor() {
+    this.processor_ = null;
+    this.generator_ = null;
+  }
+  init(track) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.processor_ = new MediaStreamTrackProcessor(track);
+      } catch (e) {
+        console.log(`[InsertableStreamHelper] MediaStreamTrackProcessor failed: ${e}`);
+        reject(e);
+      }
+      try {
+        if (track.kind === "audio") {
+          this.generator_ = new MediaStreamTrackGenerator({ kind: "audio" });
+        } else if (track.kind === "video") {
+          this.generator_ = new MediaStreamTrackGenerator({ kind: "video" });
+        } else {
+          reject("kind not supported");
+        }
+      } catch (e) {
+        console.log(`[InsertableStreamHelper] MediaStreamTrackGenerator failed: ${e}`);
+        reject(e);
+      }
+      resolve();
+    });
+  }
+  getReadable() {
+    return this.processor_.readable;
+  }
+  getWriteable() {
+    return this.generator_.writable;
+  }
+  getProccesorTrack() {
+    return this.generator_;
+  }
+}
+class MediaProcessorConnector {
+  constructor(vonageMediaProcessor) {
+    this.insertableStreamHelper_ = new InsertableStreamHelper();
+    this.mediaProcessor_ = vonageMediaProcessor;
+  }
+  setTrack(track) {
+    return new Promise((resolve, reject) => {
+      this.insertableStreamHelper_.init(track).then(() => {
+        this.mediaProcessor_.transform(this.insertableStreamHelper_.getReadable(), this.insertableStreamHelper_.getWriteable()).then(() => {
+          resolve(this.insertableStreamHelper_.getProccesorTrack());
+        }).catch((e) => {
+          reject(e);
+        });
+      }).catch((e) => {
+        reject(e);
+      });
+    });
+  }
+  destroy() {
+    return new Promise((resolve, reject) => {
+      if (this.mediaProcessor_) {
+        this.mediaProcessor_.destroy().then(() => {
+          resolve();
+        }).catch((e) => {
+          reject(e);
+        });
+      } else {
+        reject("no processor");
+      }
+    });
+  }
+}
+const encodedJs = "(function(){"use strict";class D{}D.updates={transformer_new:"New transformer",transformer_null:"Null transformer"},D.errors={transformer_none:"No transformers provided",transformer_start:"Cannot start transformer",transformer_transform:"Cannot transform frame",transformer_flush:"Cannot flush transformer"};var _e={exports:{}},xe=function(e,t){return function(){for(var s=new Array(arguments.length),a=0;a<s.length;a++)s[a]=arguments[a];return e.apply(t,s)}},mt=xe,k=Object.prototype.toString;function ge(r){return Array.isArray(r)}function ve(r){return typeof r=="undefined"}function _t(r){return r!==null&&!ve(r)&&r.constructor!==null&&!ve(r.constructor)&&typeof r.constructor.isBuffer=="function"&&r.constructor.isBuffer(r)}function Ne(r){return k.call(r)==="[object ArrayBuffer]"}function gt(r){return k.call(r)==="[object FormData]"}function vt(r){var e;return typeof ArrayBuffer!="undefined"&&ArrayBuffer.isView?e=ArrayBuffer.isView(r):e=r&&r.buffer&&Ne(r.buffer),e}function yt(r){return typeof r=="string"}function wt(r){return typeof r=="number"}function Le(r){return r!==null&&typeof r=="object"}function K(r){if(k.call(r)!=="[object Object]")return!1;var e=Object.getPrototypeOf(r);return e===null||e===Object.prototype}function Ct(r){return k.call(r)==="[object Date]"}function bt(r){return k.call(r)==="[object File]"}function Tt(r){return k.call(r)==="[object Blob]"}function Ue(r){return k.call(r)==="[object Function]"}function Et(r){return Le(r)&&Ue(r.pipe)}function Rt(r){return k.call(r)==="[object URLSearchParams]"}function Pt(r){return r.trim?r.trim():r.replace(/^\s+|\s+$/g,"")}function Ot(){return typeof navigator!="undefined"&&(navigator.product==="ReactNative"||navigator.product==="NativeScript"||navigator.product==="NS")?!1:typeof window!="undefined"&&typeof document!="undefined"}function ye(r,e){if(!(r===null||typeof r=="undefined"))if(typeof r!="object"&&(r=[r]),ge(r))for(var t=0,n=r.length;t<n;t++)e.call(null,r[t],t,r);else for(var s in r)Object.prototype.hasOwnProperty.call(r,s)&&e.call(null,r[s],s,r)}function we(){var r={};function e(s,a){K(r[a])&&K(s)?r[a]=we(r[a],s):K(s)?r[a]=we({},s):ge(s)?r[a]=s.slice():r[a]=s}for(var t=0,n=arguments.length;t<n;t++)ye(arguments[t],e);return r}function St(r,e,t){return ye(e,function(s,a){t&&typeof s=="function"?r[a]=mt(s,t):r[a]=s}),r}function It(r){return r.charCodeAt(0)===65279&&(r=r.slice(1)),r}var P={isArray:ge,isArrayBuffer:Ne,isBuffer:_t,isFormData:gt,isArrayBufferView:vt,isString:yt,isNumber:wt,isObject:Le,isPlainObject:K,isUndefined:ve,isDate:Ct,isFile:bt,isBlob:Tt,isFunction:Ue,isStream:Et,isURLSearchParams:Rt,isStandardBrowserEnv:Ot,forEach:ye,merge:we,extend:St,trim:Pt,stripBOM:It},W=P;function Be(r){return encodeURIComponent(r).replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+").replace(/%5B/gi,"[").replace(/%5D/gi,"]")}var ke=function(e,t,n){if(!t)return e;var s;if(n)s=n(t);else if(W.isURLSearchParams(t))s=t.toString();else{var a=[];W.forEach(t,function(h,g){h===null||typeof h=="undefined"||(W.isArray(h)?g=g+"[]":h=[h],W.forEach(h,function(p){W.isDate(p)?p=p.toISOString():W.isObject(p)&&(p=JSON.stringify(p)),a.push(Be(g)+"="+Be(p))}))}),s=a.join("&")}if(s){var f=e.indexOf("#");f!==-1&&(e=e.slice(0,f)),e+=(e.indexOf("?")===-1?"?":"&")+s}return e},Mt=P;function Y(){this.handlers=[]}Y.prototype.use=function(e,t,n){return this.handlers.push({fulfilled:e,rejected:t,synchronous:n?n.synchronous:!1,runWhen:n?n.runWhen:null}),this.handlers.length-1},Y.prototype.eject=function(e){this.handlers[e]&&(this.handlers[e]=null)},Y.prototype.forEach=function(e){Mt.forEach(this.handlers,function(n){n!==null&&e(n)})};var At=Y,Ft=P,xt=function(e,t){Ft.forEach(e,function(s,a){a!==t&&a.toUpperCase()===t.toUpperCase()&&(e[t]=s,delete e[a])})},He=function(e,t,n,s,a){return e.config=t,n&&(e.code=n),e.request=s,e.response=a,e.isAxiosError=!0,e.toJSON=function(){return{message:this.message,name:this.name,description:this.description,number:this.number,fileName:this.fileName,lineNumber:this.lineNumber,columnNumber:this.columnNumber,stack:this.stack,config:this.config,code:this.code,status:this.response&&this.response.status?this.response.status:null}},e},Nt=He,De=function(e,t,n,s,a){var f=new Error(e);return Nt(f,t,n,s,a)},Lt=De,Ut=function(e,t,n){var s=n.config.validateStatus;!n.status||!s||s(n.status)?e(n):t(Lt("Request failed with status code "+n.status,n.config,null,n.request,n))},Z=P,Bt=Z.isStandardBrowserEnv()?function(){return{write:function(t,n,s,a,f,l){var h=[];h.push(t+"="+encodeURIComponent(n)),Z.isNumber(s)&&h.push("expires="+new Date(s).toGMTString()),Z.isString(a)&&h.push("path="+a),Z.isString(f)&&h.push("domain="+f),l===!0&&h.push("secure"),document.cookie=h.join("; ")},read:function(t){var n=document.cookie.match(new RegExp("(^|;\\s*)("+t+")=([^;]*)"));return n?decodeURIComponent(n[3]):null},remove:function(t){this.write(t,"",Date.now()-864e5)}}}():function(){return{write:function(){},read:function(){return null},remove:function(){}}}(),kt=function(e){return/^([a-z][a-z\d+\-.]*:)?\/\//i.test(e)},Ht=function(e,t){return t?e.replace(/\/+$/,"")+"/"+t.replace(/^\/+/,""):e},Dt=kt,$t=Ht,Wt=function(e,t){return e&&!Dt(t)?$t(e,t):t},Ce=P,qt=["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","user-agent"],jt=function(e){var t={},n,s,a;return e&&Ce.forEach(e.split(`
`),function(l){if(a=l.indexOf(":"),n=Ce.trim(l.substr(0,a)).toLowerCase(),s=Ce.trim(l.substr(a+1)),n){if(t[n]&&qt.indexOf(n)>=0)return;n==="set-cookie"?t[n]=(t[n]?t[n]:[]).concat([s]):t[n]=t[n]?t[n]+", "+s:s}}),t},$e=P,Vt=$e.isStandardBrowserEnv()?function(){var e=/(msie|trident)/i.test(navigator.userAgent),t=document.createElement("a"),n;function s(a){var f=a;return e&&(t.setAttribute("href",f),f=t.href),t.setAttribute("href",f),{href:t.href,protocol:t.protocol?t.protocol.replace(/:$/,""):"",host:t.host,search:t.search?t.search.replace(/^\?/,""):"",hash:t.hash?t.hash.replace(/^#/,""):"",hostname:t.hostname,port:t.port,pathname:t.pathname.charAt(0)==="/"?t.pathname:"/"+t.pathname}}return n=s(window.location.href),function(f){var l=$e.isString(f)?s(f):f;return l.protocol===n.protocol&&l.host===n.host}}():function(){return function(){return!0}}();function be(r){this.message=r}be.prototype.toString=function(){return"Cancel"+(this.message?": "+this.message:"")},be.prototype.__CANCEL__=!0;var ee=be,te=P,zt=Ut,Gt=Bt,Jt=ke,Qt=Wt,Xt=jt,Kt=Vt,Te=De,Yt=ne,Zt=ee,We=function(e){return new Promise(function(n,s){var a=e.data,f=e.headers,l=e.responseType,h;function g(){e.cancelToken&&e.cancelToken.unsubscribe(h),e.signal&&e.signal.removeEventListener("abort",h)}te.isFormData(a)&&delete f["Content-Type"];var o=new XMLHttpRequest;if(e.auth){var p=e.auth.username||"",R=e.auth.password?unescape(encodeURIComponent(e.auth.password)):"";f.Authorization="Basic "+btoa(p+":"+R)}var y=Qt(e.baseURL,e.url);o.open(e.method.toUpperCase(),Jt(y,e.params,e.paramsSerializer),!0),o.timeout=e.timeout;function S(){if(!!o){var T="getAllResponseHeaders"in o?Xt(o.getAllResponseHeaders()):null,M=!l||l==="text"||l==="json"?o.responseText:o.response,A={data:M,status:o.status,statusText:o.statusText,headers:T,config:e,request:o};zt(function(z){n(z),g()},function(z){s(z),g()},A),o=null}}if("onloadend"in o?o.onloadend=S:o.onreadystatechange=function(){!o||o.readyState!==4||o.status===0&&!(o.responseURL&&o.responseURL.indexOf("file:")===0)||setTimeout(S)},o.onabort=function(){!o||(s(Te("Request aborted",e,"ECONNABORTED",o)),o=null)},o.onerror=function(){s(Te("Network Error",e,null,o)),o=null},o.ontimeout=function(){var M=e.timeout?"timeout of "+e.timeout+"ms exceeded":"timeout exceeded",A=e.transitional||Yt.transitional;e.timeoutErrorMessage&&(M=e.timeoutErrorMessage),s(Te(M,e,A.clarifyTimeoutError?"ETIMEDOUT":"ECONNABORTED",o)),o=null},te.isStandardBrowserEnv()){var I=(e.withCredentials||Kt(y))&&e.xsrfCookieName?Gt.read(e.xsrfCookieName):void 0;I&&(f[e.xsrfHeaderName]=I)}"setRequestHeader"in o&&te.forEach(f,function(M,A){typeof a=="undefined"&&A.toLowerCase()==="content-type"?delete f[A]:o.setRequestHeader(A,M)}),te.isUndefined(e.withCredentials)||(o.withCredentials=!!e.withCredentials),l&&l!=="json"&&(o.responseType=e.responseType),typeof e.onDownloadProgress=="function"&&o.addEventListener("progress",e.onDownloadProgress),typeof e.onUploadProgress=="function"&&o.upload&&o.upload.addEventListener("progress",e.onUploadProgress),(e.cancelToken||e.signal)&&(h=function(T){!o||(s(!T||T&&T.type?new Zt("canceled"):T),o.abort(),o=null)},e.cancelToken&&e.cancelToken.subscribe(h),e.signal&&(e.signal.aborted?h():e.signal.addEventListener("abort",h))),a||(a=null),o.send(a)})},w=P,qe=xt,er=He,tr={"Content-Type":"application/x-www-form-urlencoded"};function je(r,e){!w.isUndefined(r)&&w.isUndefined(r["Content-Type"])&&(r["Content-Type"]=e)}function rr(){var r;return(typeof XMLHttpRequest!="undefined"||typeof process!="undefined"&&Object.prototype.toString.call(process)==="[object process]")&&(r=We),r}function nr(r,e,t){if(w.isString(r))try{return(e||JSON.parse)(r),w.trim(r)}catch(n){if(n.name!=="SyntaxError")throw n}return(t||JSON.stringify)(r)}var re={transitional:{silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1},adapter:rr(),transformRequest:[function(e,t){return qe(t,"Accept"),qe(t,"Content-Type"),w.isFormData(e)||w.isArrayBuffer(e)||w.isBuffer(e)||w.isStream(e)||w.isFile(e)||w.isBlob(e)?e:w.isArrayBufferView(e)?e.buffer:w.isURLSearchParams(e)?(je(t,"application/x-www-form-urlencoded;charset=utf-8"),e.toString()):w.isObject(e)||t&&t["Content-Type"]==="application/json"?(je(t,"application/json"),nr(e)):e}],transformResponse:[function(e){var t=this.transitional||re.transitional,n=t&&t.silentJSONParsing,s=t&&t.forcedJSONParsing,a=!n&&this.responseType==="json";if(a||s&&w.isString(e)&&e.length)try{return JSON.parse(e)}catch(f){if(a)throw f.name==="SyntaxError"?er(f,this,"E_JSON_PARSE"):f}return e}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,validateStatus:function(e){return e>=200&&e<300},headers:{common:{Accept:"application/json, text/plain, */*"}}};w.forEach(["delete","get","head"],function(e){re.headers[e]={}}),w.forEach(["post","put","patch"],function(e){re.headers[e]=w.merge(tr)});var ne=re,sr=P,ir=ne,or=function(e,t,n){var s=this||ir;return sr.forEach(n,function(f){e=f.call(s,e,t)}),e},Ve=function(e){return!!(e&&e.__CANCEL__)},ze=P,Ee=or,ar=Ve,ur=ne,fr=ee;function Re(r){if(r.cancelToken&&r.cancelToken.throwIfRequested(),r.signal&&r.signal.aborted)throw new fr("canceled")}var lr=function(e){Re(e),e.headers=e.headers||{},e.data=Ee.call(e,e.data,e.headers,e.transformRequest),e.headers=ze.merge(e.headers.common||{},e.headers[e.method]||{},e.headers),ze.forEach(["delete","get","head","post","put","patch","common"],function(s){delete e.headers[s]});var t=e.adapter||ur.adapter;return t(e).then(function(s){return Re(e),s.data=Ee.call(e,s.data,s.headers,e.transformResponse),s},function(s){return ar(s)||(Re(e),s&&s.response&&(s.response.data=Ee.call(e,s.response.data,s.response.headers,e.transformResponse))),Promise.reject(s)})},O=P,Ge=function(e,t){t=t||{};var n={};function s(o,p){return O.isPlainObject(o)&&O.isPlainObject(p)?O.merge(o,p):O.isPlainObject(p)?O.merge({},p):O.isArray(p)?p.slice():p}function a(o){if(O.isUndefined(t[o])){if(!O.isUndefined(e[o]))return s(void 0,e[o])}else return s(e[o],t[o])}function f(o){if(!O.isUndefined(t[o]))return s(void 0,t[o])}function l(o){if(O.isUndefined(t[o])){if(!O.isUndefined(e[o]))return s(void 0,e[o])}else return s(void 0,t[o])}function h(o){if(o in t)return s(e[o],t[o]);if(o in e)return s(void 0,e[o])}var g={url:f,method:f,data:f,baseURL:l,transformRequest:l,transformResponse:l,paramsSerializer:l,timeout:l,timeoutMessage:l,withCredentials:l,adapter:l,responseType:l,xsrfCookieName:l,xsrfHeaderName:l,onUploadProgress:l,onDownloadProgress:l,decompress:l,maxContentLength:l,maxBodyLength:l,transport:l,httpAgent:l,httpsAgent:l,cancelToken:l,socketPath:l,responseEncoding:l,validateStatus:h};return O.forEach(Object.keys(e).concat(Object.keys(t)),function(p){var R=g[p]||a,y=R(p);O.isUndefined(y)&&R!==h||(n[p]=y)}),n},Je={version:"0.25.0"},cr=Je.version,Pe={};["object","boolean","number","function","string","symbol"].forEach(function(r,e){Pe[r]=function(n){return typeof n===r||"a"+(e<1?"n ":" ")+r}});var Qe={};Pe.transitional=function(e,t,n){function s(a,f){return"[Axios v"+cr+"] Transitional option '"+a+"'"+f+(n?". "+n:"")}return function(a,f,l){if(e===!1)throw new Error(s(f," has been removed"+(t?" in "+t:"")));return t&&!Qe[f]&&(Qe[f]=!0,console.warn(s(f," has been deprecated since v"+t+" and will be removed in the near future"))),e?e(a,f,l):!0}};function hr(r,e,t){if(typeof r!="object")throw new TypeError("options must be an object");for(var n=Object.keys(r),s=n.length;s-- >0;){var a=n[s],f=e[a];if(f){var l=r[a],h=l===void 0||f(l,a,r);if(h!==!0)throw new TypeError("option "+a+" must be "+h);continue}if(t!==!0)throw Error("Unknown option "+a)}}var dr={assertOptions:hr,validators:Pe},Xe=P,pr=ke,Ke=At,Ye=lr,se=Ge,Ze=dr,q=Ze.validators;function G(r){this.defaults=r,this.interceptors={request:new Ke,response:new Ke}}G.prototype.request=function(e,t){if(typeof e=="string"?(t=t||{},t.url=e):t=e||{},!t.url)throw new Error("Provided config url is not valid");t=se(this.defaults,t),t.method?t.method=t.method.toLowerCase():this.defaults.method?t.method=this.defaults.method.toLowerCase():t.method="get";var n=t.transitional;n!==void 0&&Ze.assertOptions(n,{silentJSONParsing:q.transitional(q.boolean),forcedJSONParsing:q.transitional(q.boolean),clarifyTimeoutError:q.transitional(q.boolean)},!1);var s=[],a=!0;this.interceptors.request.forEach(function(y){typeof y.runWhen=="function"&&y.runWhen(t)===!1||(a=a&&y.synchronous,s.unshift(y.fulfilled,y.rejected))});var f=[];this.interceptors.response.forEach(function(y){f.push(y.fulfilled,y.rejected)});var l;if(!a){var h=[Ye,void 0];for(Array.prototype.unshift.apply(h,s),h=h.concat(f),l=Promise.resolve(t);h.length;)l=l.then(h.shift(),h.shift());return l}for(var g=t;s.length;){var o=s.shift(),p=s.shift();try{g=o(g)}catch(R){p(R);break}}try{l=Ye(g)}catch(R){return Promise.reject(R)}for(;f.length;)l=l.then(f.shift(),f.shift());return l},G.prototype.getUri=function(e){if(!e.url)throw new Error("Provided config url is not valid");return e=se(this.defaults,e),pr(e.url,e.params,e.paramsSerializer).replace(/^\?/,"")},Xe.forEach(["delete","get","head","options"],function(e){G.prototype[e]=function(t,n){return this.request(se(n||{},{method:e,url:t,data:(n||{}).data}))}}),Xe.forEach(["post","put","patch"],function(e){G.prototype[e]=function(t,n,s){return this.request(se(s||{},{method:e,url:t,data:n}))}});var mr=G,_r=ee;function j(r){if(typeof r!="function")throw new TypeError("executor must be a function.");var e;this.promise=new Promise(function(s){e=s});var t=this;this.promise.then(function(n){if(!!t._listeners){var s,a=t._listeners.length;for(s=0;s<a;s++)t._listeners[s](n);t._listeners=null}}),this.promise.then=function(n){var s,a=new Promise(function(f){t.subscribe(f),s=f}).then(n);return a.cancel=function(){t.unsubscribe(s)},a},r(function(s){t.reason||(t.reason=new _r(s),e(t.reason))})}j.prototype.throwIfRequested=function(){if(this.reason)throw this.reason},j.prototype.subscribe=function(e){if(this.reason){e(this.reason);return}this._listeners?this._listeners.push(e):this._listeners=[e]},j.prototype.unsubscribe=function(e){if(!!this._listeners){var t=this._listeners.indexOf(e);t!==-1&&this._listeners.splice(t,1)}},j.source=function(){var e,t=new j(function(s){e=s});return{token:t,cancel:e}};var gr=j,vr=function(e){return function(n){return e.apply(null,n)}},yr=P,wr=function(e){return yr.isObject(e)&&e.isAxiosError===!0},et=P,Cr=xe,ie=mr,br=Ge,Tr=ne;function tt(r){var e=new ie(r),t=Cr(ie.prototype.request,e);return et.extend(t,ie.prototype,e),et.extend(t,e),t.create=function(s){return tt(br(r,s))},t}var N=tt(Tr);N.Axios=ie,N.Cancel=ee,N.CancelToken=gr,N.isCancel=Ve,N.VERSION=Je.version,N.all=function(e){return Promise.all(e)},N.spread=vr,N.isAxiosError=wr,_e.exports=N,_e.exports.default=N;var Er=_e.exports;class d{isEmpty(){return!this.isPresent()}static of(e){if(e!=null)return new rt(e);throw new TypeError("The passed value was null or undefined.")}static ofNonNull(e){return d.of(e)}static ofNullable(e){return e!=null?new rt(e):new nt}static empty(){return new nt}static from(e){switch(e.kind){case"present":return d.of(e.value);case"empty":return d.empty();default:throw new TypeError("The passed value was not an Option type.")}}}class rt extends d{constructor(e){super();this.payload=e}isPresent(){return!0}get(){return this.payload}ifPresent(e){e(this.payload)}ifPresentOrElse(e,t){e(this.payload)}filter(e){return e(this.payload)?this:d.empty()}map(e){const t=e(this.payload);return d.ofNullable(t)}flatMap(e){return e(this.payload)}or(e){return this}orElse(e){return this.payload}orElseGet(e){return this.payload}orElseThrow(e){return this.payload}orNull(){return this.payload}orUndefined(){return this.payload}toOption(){return{kind:"present",value:this.payload}}matches(e){return e.present(this.payload)}toJSON(e){return this.payload}}class nt extends d{isPresent(){return!1}constructor(){super()}get(){throw new TypeError("The optional is not present.")}ifPresent(e){}ifPresentOrElse(e,t){t()}filter(e){return this}map(e){return d.empty()}flatMap(e){return d.empty()}or(e){return e()}orElse(e){return e}orElseGet(e){return this.orElse(e())}orElseThrow(e){throw e()}orNull(){return null}orUndefined(){}toOption(){return{kind:"empty"}}matches(e){return e.empty()}toJSON(e){return null}}const Rr="1.0.1";class L{constructor(){this._report={action:d.empty(),applicationId:d.ofNullable(null),timestamp:Date.now(),fps:d.empty(),framesTransformed:d.empty(),guid:d.empty(),highestFrameTransformCpu:d.empty(),message:d.empty(),source:d.ofNullable(null),transformedFps:d.empty(),transformerType:d.empty(),variation:d.empty(),videoHeight:d.empty(),videoWidth:d.empty(),version:Rr}}action(e){return this._report.action=d.ofNullable(e),this}framesTransformed(e){return this._report.framesTransformed=d.ofNullable(e),this}fps(e){return this._report.fps=d.ofNullable(e),this}guid(e){return this._report.guid=d.ofNullable(e),this}message(e){return this._report.message=d.ofNullable(e),this}transformedFps(e){return this._report.transformedFps=d.ofNullable(e),this}transformerType(e){return this._report.transformerType=d.ofNullable(e),this}variation(e){return this._report.variation=d.ofNullable(e),this}videoHeight(e){return this._report.videoHeight=d.ofNullable(e),this}videoWidth(e){return this._report.videoWidth=d.ofNullable(e),this}build(){return this._report}}const Pr=r=>JSON.stringify(r,(e,t)=>{if(t!==null)return t});class U{static report(e){return new Promise((t,n)=>{let s=Er.create(),a={timeout:1e4,timeoutErrorMessage:"Request timeout",headers:{"Content-Type":"application/json"}};const f="https://hlg.dev.tokbox.com/dev/logging/vcp_webrtc";s.post(f,Pr(e),a).then(l=>{console.log(l),t("success")}).catch(l=>{console.log(l),n(l)})})}}var oe,Or=new Uint8Array(16);function Sr(){if(!oe&&(oe=typeof crypto!="undefined"&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||typeof msCrypto!="undefined"&&typeof msCrypto.getRandomValues=="function"&&msCrypto.getRandomValues.bind(msCrypto),!oe))throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return oe(Or)}var Ir=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;function Mr(r){return typeof r=="string"&&Ir.test(r)}for(var C=[],Oe=0;Oe<256;++Oe)C.push((Oe+256).toString(16).substr(1));function Ar(r){var e=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,t=(C[r[e+0]]+C[r[e+1]]+C[r[e+2]]+C[r[e+3]]+"-"+C[r[e+4]]+C[r[e+5]]+"-"+C[r[e+6]]+C[r[e+7]]+"-"+C[r[e+8]]+C[r[e+9]]+"-"+C[r[e+10]]+C[r[e+11]]+C[r[e+12]]+C[r[e+13]]+C[r[e+14]]+C[r[e+15]]).toLowerCase();if(!Mr(t))throw TypeError("Stringified UUID is invalid");return t}function st(r,e,t){r=r||{};var n=r.random||(r.rng||Sr)();if(n[6]=n[6]&15|64,n[8]=n[8]&63|128,e){t=t||0;for(var s=0;s<16;++s)e[t+s]=n[s];return e}return Ar(n)}const Fr=500;class xr{constructor(e){this.uuid_=st(),this.framesTransformed_=0,this.transformer_=e,this.shouldStop_=!1,this.isFlashed_=!1,this.framesFromSource_=0,this.fps_=0,this.mediaTransformerQosReportStartTimestamp_=0,this.videoHeight_=0,this.videoWidth_=0,this.transformerType_="Custom","getTransformerType"in e&&(this.transformerType_=e.getTransformerType());const t=new L().action("MediaTransformer").guid(this.uuid_).transformerType(this.transformerType_).variation("Create").build();U.report(t)}async start(e){if(this.transformer_&&typeof this.transformer_.start=="function")try{await this.transformer_.start(e)}catch{const n=new L().action("MediaTransformer").guid(this.uuid_).message(D.errors.transformer_start).transformerType(this.transformerType_).variation("Error").build();U.report(n)}}async transform(e,t){var n,s,a,f;if(this.mediaTransformerQosReportStartTimestamp_===0&&(this.mediaTransformerQosReportStartTimestamp_=Date.now()),this.videoHeight_=(n=e==null?void 0:e.displayHeight)!=null?n:0,this.videoWidth_=(s=e==null?void 0:e.displayWidth)!=null?s:0,++this.framesFromSource_,this.transformer_)if(this.shouldStop_)e.close(),this.flush(t),t.terminate();else try{await((f=(a=this.transformer_).transform)==null?void 0:f.call(a,e,t)),++this.framesTransformed_,this.framesTransformed_===Fr&&this.mediaTransformerQosReport()}catch{const h=new L().action("MediaTransformer").guid(this.uuid_).message(D.errors.transformer_transform).transformerType(this.transformerType_).variation("Error").build();U.report(h)}}async flush(e){if(this.transformer_&&typeof this.transformer_.flush=="function"&&!this.isFlashed_){this.isFlashed_=!0;try{await this.transformer_.flush(e)}catch{const s=new L().action("MediaTransformer").guid(this.uuid_).message(D.errors.transformer_transform).transformerType(this.transformerType_).variation("Error").build();U.report(s)}}this.mediaTransformerQosReport();const t=new L().action("MediaTransformer").guid(this.uuid_).transformerType(this.transformerType_).variation("Delete").build();U.report(t)}stop(){console.log("[Pipeline] Stop stream."),this.shouldStop_=!0}mediaTransformerQosReport(){let e=(Date.now()-this.mediaTransformerQosReportStartTimestamp_)/1e3,t=this.framesFromSource_/e,n=this.framesTransformed_/e;const s=new L().action("MediaTransformer").fps(t).transformedFps(n).framesTransformed(this.framesTransformed_).guid(this.uuid_).transformerType(this.transformerType_).videoHeight(this.videoHeight_).videoWidth(this.videoWidth_).variation("QoS").build();U.report(s),this.mediaTransformerQosReportStartTimestamp_=0,this.framesFromSource_=0,this.framesTransformed_=0}}class Nr{constructor(e){this.transformers_=[];for(let t of e)this.transformers_.push(new xr(t))}async start(e,t){if(!this.transformers_||this.transformers_.length===0){console.log("[Pipeline] No transformers.");return}try{let n=e;for(let s of this.transformers_)e=e.pipeThrough(new TransformStream(s));e.pipeTo(t).then(async()=>{console.log("[Pipeline] Setup."),await t.abort(),await n.cancel()}).catch(async s=>{e.cancel().then(()=>{console.log("[Pipeline] Shutting down streams after abort.")}).catch(a=>{console.error("[Pipeline] Error from stream transform:",a)}),await t.abort(s),await n.cancel(s)})}catch{this.destroy();return}console.log("[Pipeline] Pipeline started.")}async destroy(){console.log("[Pipeline] Destroying Pipeline.");for(let e of this.transformers_)e.stop()}}class Lr{constructor(){this.uuid_=st();const e=new L().action("MediaProcessor").guid(this.uuid_).variation("Create").build();U.report(e)}transform(e,t){return this.readable_=e,this.writable_=t,this.transformInternal()}transformInternal(){return new Promise((e,t)=>{if(!this.transformers_||this.transformers_.length===0){const n=new L().action("MediaProcessor").guid(this.uuid_).message(D.errors.transformer_none).variation("Error").build();U.report(n),t("[MediaProcessor] Need to set transformers.")}this.pipeline_&&this.pipeline_.destroy(),this.pipeline_=new Nr(this.transformers_),this.pipeline_.start(this.readable_,this.writable_).then(()=>{e()}).catch(n=>{t(n)})})}setTransformers(e){const t=new L().action("MediaProcessor").guid(this.uuid_).message(D.updates.transformer_new).variation("Update").build();return U.report(t),this.transformers_=e,this.readable_&&this.writable_?this.transformInternal():Promise.resolve()}destroy(){return new Promise(e=>{this.pipeline_&&this.pipeline_.destroy();const t=new L().action("MediaProcessor").guid(this.uuid_).variation("Delete").build();U.report(t),e()})}}var ae;(function(r){r.Low="Low",r.High="High"})(ae||(ae={}));class it{constructor(e){this.blurFilter_=e===ae.High?"blur(15px)":"blur(5px)"}runPostProcessing(e,t){try{e.globalCompositeOperation="destination-over",e.filter=this.blurFilter_,e.drawImage(t,0,0,t.width,t.height)}catch(n){console.log("[BlurPostProcess] Failed to draw canvas",n)}}}class Ur{constructor(e){if(this.imageCanvas_=new OffscreenCanvas(1,1),this.imageCtx_=this.imageCanvas_.getContext("2d",{alpha:!1,willReadFrequently:!0,desynchronized:!0}),!this.imageCtx_)throw new Error("Unable to create OffscreenCanvasRenderingContext2D");this.imageBlob_=void 0,fetch(e).then(t=>{t.blob().then(n=>{this.imageBlob_=n}).catch(n=>{console.error("blob error",n)})}).catch(t=>{console.error("fetch error",t)})}runPostProcessing(e,t){try{if(typeof this.imageBlob_!="undefined"&&(this.imageCanvas_.width!=t.width||this.imageCanvas_.height!=t.height)){this.imageCanvas_.width=t.width,this.imageCanvas_.height=t.height;const n="high",s={resizeWidth:t.width,resizeHeight:t.height,resizeQuality:n},a=createImageBitmap(this.imageBlob_,s).then(f=>{this.imageCtx_.drawImage(f,0,0)}).catch(f=>{console.error("error createImageBitmap",f)})}e.globalCompositeOperation="destination-over",e.drawImage(this.imageCanvas_,0,0,this.imageCanvas_.width,this.imageCanvas_.height)}catch(n){console.log("[VirtualPostProcess] Failed to draw canvas",n)}}}class Br{constructor(e=1/0){this.capacity=e,this.storage=[]}enqueue(e){if(this.size()===this.capacity)throw Error("Queue has reached max capacity, you cannot add more items");this.storage.push(e)}dequeue(){return this.storage.shift()}size(){return this.storage.length}}class kr{constructor(e){console.log("[VideoPostProcess] Ctor"),this.queue_=new Br,e&&(this.frameReader_=e.getReader(),this.frameReader_.read().then(this.processFrame.bind(this)).catch(t=>console.error(t)))}processFrame(e){e.done||(this.queue_.enqueue(e.value),this.frameReader_.read().then(this.processFrame.bind(this)).catch(t=>console.error(t)))}runPostProcessing(e,t){try{if(e.globalCompositeOperation="destination-over",this.queue_.size()>0){const n=this.queue_.dequeue();e.drawImage(n,0,0,t.width,t.height),n.close()}else e.drawImage(t,0,0,t.width,t.height)}catch(n){console.log("[VideoPostProcess] Failed to draw canvas",n)}}}function Hr(){return"selfie_segmentation_landscape"}var ue=function(){var r=typeof document!="undefined"&&document.currentScript?document.currentScript.src:void 0;return function(e){e=e||{};var t=typeof e!="undefined"?e:{},n,s;t.ready=new Promise(function(i,u){n=i,s=u});var a={},f;for(f in t)t.hasOwnProperty(f)&&(a[f]=t[f]);var l="./this.program",h=function(i,u){throw u},g=!0,o="";function p(i){return t.locateFile?t.locateFile(i,o):o+i}var R;typeof document!="undefined"&&document.currentScript&&(o=document.currentScript.src),r&&(o=r),o.indexOf("blob:")!==0?o=o.substr(0,o.replace(/[?#].*/,"").lastIndexOf("/")+1):o="";var y=t.print||console.log.bind(console),S=t.printErr||console.warn.bind(console);for(f in a)a.hasOwnProperty(f)&&(t[f]=a[f]);a=null,t.arguments,t.thisProgram&&(l=t.thisProgram),t.quit&&(h=t.quit);var I;t.wasmBinary&&(I=t.wasmBinary);var T=t.noExitRuntime||!0;typeof WebAssembly!="object"&&H("no native wasm support detected");var M,A=!1,fe=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):void 0;function z(i,u,c){for(var m=u+c,v=u;i[v]&&!(v>=m);)++v;if(v-u>16&&i.subarray&&fe)return fe.decode(i.subarray(u,v));for(var b="";u<v;){var _=i[u++];if(!(_&128)){b+=String.fromCharCode(_);continue}var E=i[u++]&63;if((_&224)==192){b+=String.fromCharCode((_&31)<<6|E);continue}var B=i[u++]&63;if((_&240)==224?_=(_&15)<<12|E<<6|B:_=(_&7)<<18|E<<12|B<<6|i[u++]&63,_<65536)b+=String.fromCharCode(_);else{var pt=_-65536;b+=String.fromCharCode(55296|pt>>10,56320|pt&1023)}}return b}function le(i,u){return i?z(J,i,u):""}function qr(i,u,c){for(var m=0;m<i.length;++m)ce[u++>>0]=i.charCodeAt(m);c||(ce[u>>0]=0)}function jr(i,u){return i%u>0&&(i+=u-i%u),i}var ot,ce,J,F;function at(i){ot=i,t.HEAP8=ce=new Int8Array(i),t.HEAP16=new Int16Array(i),t.HEAP32=F=new Int32Array(i),t.HEAPU8=J=new Uint8Array(i),t.HEAPU16=new Uint16Array(i),t.HEAPU32=new Uint32Array(i),t.HEAPF32=new Float32Array(i),t.HEAPF64=new Float64Array(i)}t.INITIAL_MEMORY;var Ie,ut=[],ft=[],lt=[],Vr=0;function zr(){return T||Vr>0}function Gr(){if(t.preRun)for(typeof t.preRun=="function"&&(t.preRun=[t.preRun]);t.preRun.length;)Xr(t.preRun.shift());Me(ut)}function Jr(){Me(ft)}function Qr(){if(t.postRun)for(typeof t.postRun=="function"&&(t.postRun=[t.postRun]);t.postRun.length;)Yr(t.postRun.shift());Me(lt)}function Xr(i){ut.unshift(i)}function Kr(i){ft.unshift(i)}function Yr(i){lt.unshift(i)}var $=0,Q=null;function Zr(i){$++,t.monitorRunDependencies&&t.monitorRunDependencies($)}function en(i){if($--,t.monitorRunDependencies&&t.monitorRunDependencies($),$==0&&Q){var u=Q;Q=null,u()}}t.preloadedImages={},t.preloadedAudios={};function H(i){t.onAbort&&t.onAbort(i),i="Aborted("+i+")",S(i),A=!0,i+=". Build with -s ASSERTIONS=1 for more info.";var u=new WebAssembly.RuntimeError(i);throw s(u),u}var tn="data:application/octet-stream;base64,";function ct(i){return i.startsWith(tn)}var x;x="tflite-simd.wasm",ct(x)||(x=p(x));function ht(i){try{if(i==x&&I)return new Uint8Array(I);if(!R)throw"both async and sync fetching of the wasm failed"}catch(u){H(u)}}function rn(){return!I&&g&&typeof fetch=="function"?fetch(x,{credentials:"same-origin"}).then(function(i){if(!i.ok)throw"failed to load wasm binary file at '"+x+"'";return i.arrayBuffer()}).catch(function(){return ht(x)}):Promise.resolve().then(function(){return ht(x)})}function nn(){var i={a:Rn};function u(_,E){var B=_.exports;t.asm=B,M=t.asm.q,at(M.buffer),Ie=t.asm.D,Kr(t.asm.r),en()}Zr();function c(_){u(_.instance)}function m(_){return rn().then(function(E){return WebAssembly.instantiate(E,i)}).then(function(E){return E}).then(_,function(E){S("failed to asynchronously prepare wasm: "+E),H(E)})}function v(){return!I&&typeof WebAssembly.instantiateStreaming=="function"&&!ct(x)&&typeof fetch=="function"?fetch(x,{credentials:"same-origin"}).then(function(_){var E=WebAssembly.instantiateStreaming(_,i);return E.then(c,function(B){return S("wasm streaming compile failed: "+B),S("falling back to ArrayBuffer instantiation"),m(c)})}):m(c)}if(t.instantiateWasm)try{var b=t.instantiateWasm(i,u);return b}catch(_){return S("Module.instantiateWasm callback failed with error: "+_),!1}return v().catch(s),{}}function Me(i){for(;i.length>0;){var u=i.shift();if(typeof u=="function"){u(t);continue}var c=u.func;typeof c=="number"?u.arg===void 0?Ie.get(c)():Ie.get(c)(u.arg):c(u.arg===void 0?null:u.arg)}}function sn(i,u,c,m){H("Assertion failed: "+le(i)+", at: "+[u?le(u):"unknown filename",c,m?le(m):"unknown function"])}function on(i,u){H("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking")}function an(i,u){H("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking")}function un(){H("")}var he;he=function(){return performance.now()};var fn=!0;function ln(i){return F[dt()>>2]=i,i}function cn(i,u){var c;if(i===0)c=Date.now();else if((i===1||i===4)&&fn)c=he();else return ln(28),-1;return F[u>>2]=c/1e3|0,F[u+4>>2]=c%1e3*1e3*1e3|0,0}function hn(){return 2147483648}function dn(i,u,c){J.copyWithin(i,u,u+c)}function pn(i){try{return M.grow(i-ot.byteLength+65535>>>16),at(M.buffer),1}catch{}}function mn(i){var u=J.length;i=i>>>0;var c=2147483648;if(i>c)return!1;for(var m=1;m<=4;m*=2){var v=u*(1+.2/m);v=Math.min(v,i+100663296);var b=Math.min(c,jr(Math.max(i,v),65536)),_=pn(b);if(_)return!0}return!1}function _n(i){for(var u=he();he()-u<i;);}var Ae={};function gn(){return l||"./this.program"}function X(){if(!X.strings){var i=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",u={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:i,_:gn()};for(var c in Ae)Ae[c]===void 0?delete u[c]:u[c]=Ae[c];var m=[];for(var c in u)m.push(c+"="+u[c]);X.strings=m}return X.strings}var de={mappings:{},buffers:[null,[],[]],printChar:function(i,u){var c=de.buffers[i];u===0||u===10?((i===1?y:S)(z(c,0)),c.length=0):c.push(u)},varargs:void 0,get:function(){de.varargs+=4;var i=F[de.varargs-4>>2];return i},getStr:function(i){var u=le(i);return u},get64:function(i,u){return i}};function vn(i,u){var c=0;return X().forEach(function(m,v){var b=u+c;F[i+v*4>>2]=b,qr(m,b),c+=m.length+1}),0}function yn(i,u){var c=X();F[i>>2]=c.length;var m=0;return c.forEach(function(v){m+=v.length+1}),F[u>>2]=m,0}function wn(i){On(i)}function Cn(i){return 0}function bn(i,u,c,m,v){}function Tn(i,u,c,m){for(var v=0,b=0;b<c;b++){for(var _=F[u+b*8>>2],E=F[u+(b*8+4)>>2],B=0;B<E;B++)de.printChar(i,J[_+B]);v+=E}return F[m>>2]=v,0}function En(){if(typeof crypto=="object"&&typeof crypto.getRandomValues=="function"){var i=new Uint8Array(1);return function(){return crypto.getRandomValues(i),i[0]}}else return function(){H("randomDevice")}}function pe(i,u){pe.randomDevice||(pe.randomDevice=En());for(var c=0;c<u;c++)ce[i+c>>0]=pe.randomDevice();return 0}var Rn={a:sn,e:on,d:an,b:un,n:cn,h:hn,l:dn,m:mn,p:_n,f:vn,g:yn,j:wn,i:Cn,k:bn,c:Tn,o:pe};nn(),t.___wasm_call_ctors=function(){return(t.___wasm_call_ctors=t.asm.r).apply(null,arguments)},t._getModelBufferMemoryOffset=function(){return(t._getModelBufferMemoryOffset=t.asm.s).apply(null,arguments)},t._getInputMemoryOffset=function(){return(t._getInputMemoryOffset=t.asm.t).apply(null,arguments)},t._getInputHeight=function(){return(t._getInputHeight=t.asm.u).apply(null,arguments)},t._getInputWidth=function(){return(t._getInputWidth=t.asm.v).apply(null,arguments)},t._getInputChannelCount=function(){return(t._getInputChannelCount=t.asm.w).apply(null,arguments)},t._getOutputMemoryOffset=function(){return(t._getOutputMemoryOffset=t.asm.x).apply(null,arguments)},t._getOutputHeight=function(){return(t._getOutputHeight=t.asm.y).apply(null,arguments)},t._getOutputWidth=function(){return(t._getOutputWidth=t.asm.z).apply(null,arguments)},t._getOutputChannelCount=function(){return(t._getOutputChannelCount=t.asm.A).apply(null,arguments)},t._loadModel=function(){return(t._loadModel=t.asm.B).apply(null,arguments)},t._runInference=function(){return(t._runInference=t.asm.C).apply(null,arguments)};var dt=t.___errno_location=function(){return(dt=t.___errno_location=t.asm.E).apply(null,arguments)},me;function Pn(i){this.name="ExitStatus",this.message="Program terminated with exit("+i+")",this.status=i}Q=function i(){me||Fe(),me||(Q=i)};function Fe(i){if($>0||(Gr(),$>0))return;function u(){me||(me=!0,t.calledRun=!0,!A&&(Jr(),n(t),t.onRuntimeInitialized&&t.onRuntimeInitialized(),Qr()))}t.setStatus?(t.setStatus("Running..."),setTimeout(function(){setTimeout(function(){t.setStatus("")},1),u()},1)):u()}t.run=Fe;function On(i,u){Sn(i)}function Sn(i){zr()||(t.onExit&&t.onExit(i),A=!0),h(i,new Pn(i))}if(t.preInit)for(typeof t.preInit=="function"&&(t.preInit=[t.preInit]);t.preInit.length>0;)t.preInit.pop()();return Fe(),e.ready}}();typeof exports=="object"&&typeof module=="object"?module.exports=ue:typeof define=="function"&&define.amd?define([],function(){return ue}):typeof exports=="object"&&(exports.createVonageTFLiteSimdModule=ue);class Dr{constructor(){this.isSIMDSupported_=!1,this.isThreadsSupported_=!1,this.inputWidth_=0,this.inputHeight_=0,this.inputChannelCount_=0,this.inputMemoryOffset_=0,this.outputWidth_=0,this.outputHeight_=0,this.outputChannelCount_=0,this.outputMemoryOffset_=0}}async function $r(r){let e=new Dr;var t=new Promise(function(n,s){async function a(){return ue({locateFile:function(h){return r+h}})}async function f(l){return new Promise(async(h,g)=>{const o=l;if(typeof o=="undefined")return g("TFLite backend unavailable: wasmSimd");const p=Hr();console.log("Loading tflite model:",p);let R=r+`models/${p}.tflite`;console.log("TFLite modelUrl: "+R);try{const S=await(await fetch(R)).arrayBuffer();console.log("Model buffer size:",S.byteLength);const I=o._getModelBufferMemoryOffset();console.log("Model buffer memory offset:",I),console.log("Loading model buffer..."),o.HEAPU8.set(new Uint8Array(S),I);const T=o._loadModel(S.byteLength);if(console.log("Load model result:",T),T!==0){g("Cannot load model");return}e.inputWidth_=o._getInputWidth(),e.inputHeight_=o._getInputHeight(),e.inputChannelCount_=o._getInputChannelCount(),e.inputMemoryOffset_=o._getInputMemoryOffset(),console.log("Input memory offset:",e.inputMemoryOffset_),console.log("Input height:",e.inputHeight_),console.log("Input width:",e.inputWidth_),console.log("Input channels:",e.inputChannelCount_),e.outputMemoryOffset_=o._getOutputMemoryOffset(),e.outputWidth_=o._getOutputWidth(),e.outputHeight_=o._getOutputHeight(),e.outputChannelCount_=o._getOutputChannelCount(),console.log("Output memory offset:",e.outputMemoryOffset_),console.log("Output height:",e.outputHeight_),console.log("Output width:",e.outputWidth_),console.log("Output channels:",e.outputChannelCount_),e.selectedTFLite_=o}catch(y){g(y);return}h()})}a().then(l=>{if(l===null)throw console.error("loadTFLite null"),"loadTFLite null";f(l).then(h=>{n(e)}).catch(h=>{console.error("loadTFLiteModel error"),s("loadTFLiteModel error")})}).catch(l=>{console.error("loadTFLite error:",l),s("loadTFLite error:"+l)})});return t}class Wr{constructor(e){this.blurFilter_=e===ae.High?"blur(15px)":"blur(5px)"}runPostProcessing(e,t){try{e.globalCompositeOperation="source-in",e.filter=this.blurFilter_,e.drawImage(t,0,0,t.width,t.height),e.globalCompositeOperation="destination-over",e.filter="blur(0px)",e.drawImage(t,0,0,t.width,t.height)}catch(n){console.log("[BlurPostProcess] Failed to draw canvas",n)}}}const V=class{constructor(r){if(this.config_=r,this.frameCounter_=0,this.lastProcessedTimestamp_=0,this.resultCanvas_=new OffscreenCanvas(1,1),this.resultCtx_=this.resultCanvas_.getContext("2d",{alpha:!1,desynchronized:!0}),!this.resultCtx_)throw new Error("Unable to create OffscreenCanvasRenderingContext2D");if(this.segmentationMaskCanvas_=new OffscreenCanvas(1,1),this.segmentationMaskCtx_=this.segmentationMaskCanvas_.getContext("2d",{alpha:!1,desynchronized:!0}),!this.segmentationMaskCtx_)throw new Error("Unable to create OffscreenCanvasRenderingContext2D");if(this.segmentationMaskFrameCanvas_=new OffscreenCanvas(1,1),this.segmentationMaskFrameCtx_=this.segmentationMaskFrameCanvas_.getContext("2d",{alpha:!1,desynchronized:!0}),!this.segmentationMaskFrameCtx_)throw new Error("Unable to create OffscreenCanvasRenderingContext2D");this.segmentationPixelCount_=0,this.inputMemoryOffset_=0,this.outputMemoryOffset_=0,r.transformerType==="VirtualBackground"?(this.timerGap_=V.VIRTUAL_PROCESS_GAP_MICRO_SECOND,this.postProcessInterface_=new Ur(r.backgroundAssetUri)):r.transformerType==="BackgroundBlur"?(this.timerGap_=V.BLUR_PROCESS_GAP_MICRO_SECOND,this.postProcessInterface_=new it(r.radius)):r.transformerType==="VideoBackground"?this.timerGap_=V.BLUR_PROCESS_GAP_MICRO_SECOND:r.transformerType==="SilueteBlur"?(this.timerGap_=V.BLUR_PROCESS_GAP_MICRO_SECOND,this.postProcessInterface_=new Wr(r.radius)):(this.timerGap_=V.BLUR_PROCESS_GAP_MICRO_SECOND,this.postProcessInterface_=new it)}async start(){await $r(this.config_.wasmAssetUriPath).then(r=>{r&&(this.voangeTFLiteInfo_=r,this.segmentationMaskCanvas_.width=this.voangeTFLiteInfo_.inputWidth_,this.segmentationMaskCanvas_.height=this.voangeTFLiteInfo_.inputHeight_,this.segmentationPixelCount_=this.voangeTFLiteInfo_.inputWidth_*this.voangeTFLiteInfo_.inputHeight_,this.segmentationMask_=new ImageData(this.voangeTFLiteInfo_.inputWidth_,this.voangeTFLiteInfo_.inputHeight_),this.inputMemoryOffset_=this.voangeTFLiteInfo_.inputMemoryOffset_/4,this.outputMemoryOffset_=this.voangeTFLiteInfo_.outputMemoryOffset_/4)}).catch(r=>{console.log("error useTFLite:",r)})}async transform(r,e){(this.resultCanvas_.width!=r.displayWidth||this.resultCanvas_.height!=r.displayHeight)&&(this.resultCanvas_.width=r.displayWidth,this.resultCanvas_.height=r.displayHeight),(this.segmentationMaskFrameCanvas_.width!=r.displayWidth||this.segmentationMaskFrameCanvas_.height!=r.displayHeight)&&(this.segmentationMaskFrameCanvas_.width=r.displayWidth,this.segmentationMaskFrameCanvas_.height=r.displayHeight);const t=r.timestamp;createImageBitmap(r).then(n=>{r.close(),this.processFrame(e,n,t)}).catch(n=>{console.error("createImageBitmap",n),e.enqueue(r)})}processFrame(r,e,t){t-this.lastProcessedTimestamp_>=this.timerGap_&&(this.lastProcessedTimestamp_=t,this.processSource(e)),this.resultCtx_.globalCompositeOperation="copy",this.resultCtx_.drawImage(this.segmentationMaskFrameCanvas_,0,0,this.segmentationMaskFrameCanvas_.width,this.segmentationMaskFrameCanvas_.height),this.resultCtx_.globalCompositeOperation="source-atop",this.resultCtx_.filter="none",this.resultCtx_.drawImage(e,0,0,e.width,e.height),this.postProcessInterface_&&this.postProcessInterface_.runPostProcessing(this.resultCtx_,e),r.enqueue(new VideoFrame(this.resultCanvas_,{timestamp:t,alpha:"discard"})),this.frameCounter_++}processSource(r){this.segmentationMaskCtx_.globalCompositeOperation="copy",this.segmentationMaskCtx_.drawImage(r,0,0,r.width,r.height,0,0,this.voangeTFLiteInfo_.inputWidth_,this.voangeTFLiteInfo_.inputHeight_);let e=this.segmentationMaskCtx_.getImageData(0,0,this.voangeTFLiteInfo_.inputWidth_,this.voangeTFLiteInfo_.inputHeight_);for(let t=0;t<this.segmentationPixelCount_;t++)this.voangeTFLiteInfo_.selectedTFLite_.HEAPF32[this.inputMemoryOffset_+t*3]=e.data[t*4]/255,this.voangeTFLiteInfo_.selectedTFLite_.HEAPF32[this.inputMemoryOffset_+t*3+1]=e.data[t*4+1]/255,this.voangeTFLiteInfo_.selectedTFLite_.HEAPF32[this.inputMemoryOffset_+t*3+2]=e.data[t*4+2]/255;this.voangeTFLiteInfo_.selectedTFLite_._runInference();for(let t=0;t<this.segmentationPixelCount_;t++){const n=this.voangeTFLiteInfo_.selectedTFLite_.HEAPF32[this.outputMemoryOffset_+t];this.segmentationMask_.data[t*4+3]=255*n}this.segmentationMaskCtx_.putImageData(this.segmentationMask_,0,0),this.segmentationMaskFrameCtx_.globalCompositeOperation="copy",this.segmentationMaskFrameCtx_.drawImage(this.segmentationMaskCanvas_,0,0,this.voangeTFLiteInfo_.inputWidth_,this.voangeTFLiteInfo_.inputHeight_,0,0,this.segmentationMaskFrameCanvas_.width,this.segmentationMaskFrameCanvas_.height)}flush(){}getTransformerType(){return"BackgroundTransformer"}setVideoBGReadable(r){this.config_.transformerType==="VideoBackground"&&(this.postProcessInterface_=new kr(r))}};let Se=V;if(Se.BLUR_PROCESS_GAP_MICRO_SECOND=2e5,Se.VIRTUAL_PROCESS_GAP_MICRO_SECOND=15e4,typeof importScripts=="function"){let r=new Lr;onmessage=async e=>{const{operation:t}=e.data;if(console.log("operation=",t),t==="transform"){const{readable:n,writable:s,config:a,videoBGReadable:f}=e.data;let l=[];const h=new Se(JSON.parse(a));h.setVideoBGReadable(f),l.push(h),r.setTransformers(l).then(()=>{r.transform(n,s).then(()=>{postMessage("success")}).catch(g=>{postMessage("error:"+g)})}).catch(g=>{postMessage("error:"+g)})}else t==="destroy"&&r.destroy().then(()=>{postMessage("success")}).catch(n=>{postMessage("error:"+n)})}}})();
";
+const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" });
+function WorkerWrapper() {
+  const objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob);
+  try {
+    return objURL ? new Worker(objURL) : new Worker("data:application/javascript;base64," + encodedJs, { type: "module" });
+  } finally {
+    objURL && (window.URL || window.webkitURL).revokeObjectURL(objURL);
+  }
+}
+class VonageMediaProcessorWorker {
+  constructor(config) {
+    this.config_ = config;
+    this.worker_ = new WorkerWrapper();
+  }
+  transform(readable, writable) {
+    return new Promise(async (resolve, reject) => {
+      console.log("Created a worker thread.");
+      const onMessage = new Promise((resolve2, reject2) => {
+        this.worker_.addEventListener("message", function handleMsgFromWorker(msg) {
+          if (msg.data === "success") {
+            resolve2();
+          } else {
+            reject2(msg.data);
+          }
+        });
+      });
+      if (this.config_.transformerType === "VideoBackground") {
+        const bgvideo = document.createElement("video");
+        bgvideo.src = this.config_.backgroundAssetUri;
+        bgvideo.muted = true;
+        try {
+          await bgvideo.play();
+        } catch (error) {
+          reject(error);
+          return;
+        }
+        const bgvideotrack = bgvideo.captureStream().getVideoTracks()[0];
+        const processor = new MediaStreamTrackProcessor(bgvideotrack);
+        const videoBGReadable = processor.readable;
+        this.worker_.postMessage({
+          operation: "transform",
+          readable,
+          writable,
+          config: JSON.stringify(this.config_),
+          videoBGReadable
+        }, [readable, writable, videoBGReadable]);
+      } else {
+        this.worker_.postMessage({
+          operation: "transform",
+          readable,
+          writable,
+          config: JSON.stringify(this.config_)
+        }, [readable, writable]);
+      }
+      onMessage.then(() => {
+        console.log("Worker inited");
+        resolve();
+      }).catch((e) => {
+        console.log("Worker inited error");
+        reject(e);
+      });
+    });
+  }
+  destroy() {
+    return new Promise(async (resolve, reject) => {
+      console.log("destroy a worker thread.");
+      const onMessage = new Promise((resolve2, reject2) => {
+        this.worker_.addEventListener("message", function handleMsgFromWorker(msg) {
+          if (msg.data === "success") {
+            resolve2();
+          } else {
+            reject2(msg.data);
+          }
+        });
+      });
+      this.worker_.postMessage({
+        operation: "destroy"
+      });
+      onMessage.then(() => {
+        console.log("Worker destroyed");
+        resolve();
+      }).catch((e) => {
+        console.log("Worker destroy error");
+        reject(e);
+      });
+    });
+  }
+}
+var BlurRadius;
+(function(BlurRadius2) {
+  BlurRadius2["Low"] = "Low";
+  BlurRadius2["High"] = "High";
+})(BlurRadius || (BlurRadius = {}));
+const simd = async () => WebAssembly.validate(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 253, 15, 253, 98, 11]));
+function isSupported() {
+  return new Promise(async (resolve, reject) => {
+    try {
+      await isSupported$1();
+    } catch (e) {
+      reject(e);
+      return;
+    }
+    simd().then((isSIMDSupported) => {
+      if (isSIMDSupported === false) {
+        reject("Your browser does not support WebAssembly features.");
+        return;
+      }
+      resolve();
+    }).catch((e) => {
+      reject(e);
+    });
+  });
+}
+function createVonageMediaProcessorConnector(config) {
+  return new Promise(async (resolve, reject) => {
+    const connector = new MediaProcessorConnector(new VonageMediaProcessorWorker(config));
+    resolve(connector);
+    return;
+  });
+}
+export { BlurRadius, createVonageMediaProcessorConnector, isSupported };