inl-ui 0.1.25 → 0.1.26

package/dist/components/index.cjs

@@ -6,7 +6,7 @@ var vue = require('vue');
 var iconsVue = require('@ant-design/icons-vue');
 var vueRouter = require('vue-router');
 var core = require('@vueuse/core');
-var axios = require('axios');
+var axios$2 = require('axios');
 var antDesignVue = require('ant-design-vue');
 var _ = require('lodash');
 var dayjs = require('dayjs');
@@ -18,7 +18,7 @@ var mobile = require('@sszj-temp/mobile');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios$2);
 var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
 var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
 var EZUIKit__default = /*#__PURE__*/_interopDefaultLegacy(EZUIKit);
@@ -579,6 +579,10 @@ const Events$1 = {
   WEBRTC_ON_REMOTE_STREAMS: "WEBRTC_ON_REMOTE_STREAMS",
   WEBRTC_ON_LOCAL_STREAM: "WEBRTC_ON_LOCAL_STREAM",
   WEBRTC_ON_CONNECTION_STATE_CHANGE: "WEBRTC_ON_CONNECTION_STATE_CHANGE",
+  WEBRTC_ON_DATA_CHANNEL_OPEN: "WEBRTC_ON_DATA_CHANNEL_OPEN",
+  WEBRTC_ON_DATA_CHANNEL_CLOSE: "WEBRTC_ON_DATA_CHANNEL_CLOSE",
+  WEBRTC_ON_DATA_CHANNEL_ERR: "WEBRTC_ON_DATA_CHANNEL_ERR",
+  WEBRTC_ON_DATA_CHANNEL_MSG: "WEBRTC_ON_DATA_CHANNEL_MSG",
   CAPTURE_STREAM_FAILED: "CAPTURE_STREAM_FAILED"
 };
 function isFirefox() {
@@ -727,16 +731,16 @@ function detectBrowser(window2) {
   }
   return result;
 }
-function isObject(val) {
+function isObject$1(val) {
   return Object.prototype.toString.call(val) === "[object Object]";
 }
-function compactObject(data) {
-  if (!isObject(data)) {
-    return data;
+function compactObject(data2) {
+  if (!isObject$1(data2)) {
+    return data2;
   }
-  return Object.keys(data).reduce(function (accumulator, key) {
-    const isObj = isObject(data[key]);
-    const value = isObj ? compactObject(data[key]) : data[key];
+  return Object.keys(data2).reduce(function (accumulator, key) {
+    const isObj = isObject$1(data2[key]);
+    const value = isObj ? compactObject(data2[key]) : data2[key];
     const isEmptyObject = isObj && !Object.keys(value).length;
     if (value === void 0 || isEmptyObject) {
       return accumulator;
@@ -1540,8 +1544,8 @@ function filterIceServers$1(iceServers, edgeVersion) {
     if (server && (server.urls || server.url)) {
       let urls = server.urls || server.url;
       if (server.url && !server.urls) ;
-      const isString = typeof urls === "string";
-      if (isString) {
+      const isString2 = typeof urls === "string";
+      if (isString2) {
         urls = [urls];
       }
       urls = urls.filter(url => {
@@ -1556,7 +1560,7 @@ function filterIceServers$1(iceServers, edgeVersion) {
         return validTurn && !hasTurn;
       });
       delete server.url;
-      server.urls = isString ? urls[0] : urls;
+      server.urls = isString2 ? urls[0] : urls;
       return !!urls.length;
     }
   });
@@ -2212,8 +2216,8 @@ function filterIceServers(iceServers, edgeVersion) {
     if (server && (server.urls || server.url)) {
       var urls = server.urls || server.url;
       if (server.url && !server.urls) ;
-      var isString = typeof urls === "string";
-      if (isString) {
+      var isString2 = typeof urls === "string";
+      if (isString2) {
         urls = [urls];
       }
       urls = urls.filter(function (url) {
@@ -2225,7 +2229,7 @@ function filterIceServers(iceServers, edgeVersion) {
         return url.indexOf("stun:") === 0 && edgeVersion >= 14393 && url.indexOf("?transport=udp") === -1;
       });
       delete server.url;
-      server.urls = isString ? urls[0] : urls;
+      server.urls = isString2 ? urls[0] : urls;
       return !!urls.length;
     }
   });
@@ -4077,13 +4081,13 @@ function shimCallbacksAPI(window2) {
   if (typeof window2 !== "object" || !window2.RTCPeerConnection) {
     return;
   }
-  const prototype = window2.RTCPeerConnection.prototype;
-  const origCreateOffer = prototype.createOffer;
-  const origCreateAnswer = prototype.createAnswer;
-  const setLocalDescription = prototype.setLocalDescription;
-  const setRemoteDescription = prototype.setRemoteDescription;
-  const addIceCandidate = prototype.addIceCandidate;
-  prototype.createOffer = function createOffer(successCallback, failureCallback) {
+  const prototype2 = window2.RTCPeerConnection.prototype;
+  const origCreateOffer = prototype2.createOffer;
+  const origCreateAnswer = prototype2.createAnswer;
+  const setLocalDescription = prototype2.setLocalDescription;
+  const setRemoteDescription = prototype2.setRemoteDescription;
+  const addIceCandidate = prototype2.addIceCandidate;
+  prototype2.createOffer = function createOffer(successCallback, failureCallback) {
     const options = arguments.length >= 2 ? arguments[2] : arguments[0];
     const promise = origCreateOffer.apply(this, [options]);
     if (!failureCallback) {
@@ -4092,7 +4096,7 @@ function shimCallbacksAPI(window2) {
     promise.then(successCallback, failureCallback);
     return Promise.resolve();
   };
-  prototype.createAnswer = function createAnswer(successCallback, failureCallback) {
+  prototype2.createAnswer = function createAnswer(successCallback, failureCallback) {
     const options = arguments.length >= 2 ? arguments[2] : arguments[0];
     const promise = origCreateAnswer.apply(this, [options]);
     if (!failureCallback) {
@@ -4109,7 +4113,7 @@ function shimCallbacksAPI(window2) {
     promise.then(successCallback, failureCallback);
     return Promise.resolve();
   };
-  prototype.setLocalDescription = withCallback;
+  prototype2.setLocalDescription = withCallback;
   withCallback = function (description, successCallback, failureCallback) {
     const promise = setRemoteDescription.apply(this, [description]);
     if (!failureCallback) {
@@ -4118,7 +4122,7 @@ function shimCallbacksAPI(window2) {
     promise.then(successCallback, failureCallback);
     return Promise.resolve();
   };
-  prototype.setRemoteDescription = withCallback;
+  prototype2.setRemoteDescription = withCallback;
   withCallback = function (candidate, successCallback, failureCallback) {
     const promise = addIceCandidate.apply(this, [candidate]);
     if (!failureCallback) {
@@ -4127,7 +4131,7 @@ function shimCallbacksAPI(window2) {
     promise.then(successCallback, failureCallback);
     return Promise.resolve();
   };
-  prototype.addIceCandidate = withCallback;
+  prototype2.addIceCandidate = withCallback;
 }
 function shimGetUserMedia(window2) {
   const navigator2 = window2 && window2.navigator;
@@ -4277,7 +4281,7 @@ function shimRTCIceCandidate(window2) {
       const nativeCandidate = new NativeRTCIceCandidate(args);
       const parsedCandidate = sdp.parseCandidate(args.candidate);
       const augmentedCandidate = Object.assign(nativeCandidate, parsedCandidate);
-      augmentedCandidate.toJSON = function toJSON() {
+      augmentedCandidate.toJSON = function toJSON2() {
         return {
           candidate: augmentedCandidate.candidate,
           sdpMid: augmentedCandidate.sdpMid,
@@ -4407,8 +4411,8 @@ function shimSendThrowTypeError(window2) {
   function wrapDcSend(dc, pc) {
     const origDataChannelSend = dc.send;
     dc.send = function send() {
-      const data = arguments[0];
-      const length = data.length || data.size || data.byteLength;
+      const data2 = arguments[0];
+      const length = data2.length || data2.size || data2.byteLength;
       if (dc.readyState === "open" && pc.sctp && length > pc.sctp.maxMessageSize) {
         throw new TypeError("Message too large (can send a maximum of " + pc.sctp.maxMessageSize + " bytes)");
       }
@@ -4636,21 +4640,21 @@ adapterFactory({
 });
 class AudioTrackConstraints {
   // eslint-disable-next-line require-jsdoc
-  constructor(source) {
-    if (!Object.values(AudioSourceInfo).some(v => v === source)) {
+  constructor(source2) {
+    if (!Object.values(AudioSourceInfo).some(v => v === source2)) {
       throw new TypeError("Invalid source.");
     }
-    this.source = source;
+    this.source = source2;
     this.deviceId = void 0;
   }
 }
 class VideoTrackConstraints {
   // eslint-disable-next-line require-jsdoc
-  constructor(source) {
-    if (!Object.values(VideoSourceInfo).some(v => v === source)) {
+  constructor(source2) {
+    if (!Object.values(VideoSourceInfo).some(v => v === source2)) {
       throw new TypeError("Invalid source.");
     }
-    this.source = source;
+    this.source = source2;
     this.deviceId = void 0;
     this.resolution = void 0;
     this.frameRate = void 0;
@@ -4788,21 +4792,1175 @@ class Event$1 {
   offAll() {
     this.listener = {};
   }
-  dispatch(event, data) {
+  dispatch(event, data2) {
     if (this.listener[event]) {
       this.listener[event].map(each => {
-        each.apply(null, [data]);
+        each.apply(null, [data2]);
       });
       return true;
     }
     return false;
   }
 }
+var bind = function bind2(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 toString = Object.prototype.toString;
+var kindOf = function (cache) {
+  return function (thing) {
+    var str = toString.call(thing);
+    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+  };
+}( /* @__PURE__ */Object.create(null));
+function kindOfTest(type) {
+  type = type.toLowerCase();
+  return function isKindOf(thing) {
+    return kindOf(thing) === type;
+  };
+}
+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);
+}
+var isArrayBuffer = kindOfTest("ArrayBuffer");
+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 (kindOf(val) !== "object") {
+    return false;
+  }
+  var prototype2 = Object.getPrototypeOf(val);
+  return prototype2 === null || prototype2 === Object.prototype;
+}
+var isDate = kindOfTest("Date");
+var isFile = kindOfTest("File");
+var isBlob = kindOfTest("Blob");
+var isFileList = kindOfTest("FileList");
+function isFunction(val) {
+  return toString.call(val) === "[object Function]";
+}
+function isStream(val) {
+  return isObject(val) && isFunction(val.pipe);
+}
+function isFormData(thing) {
+  var pattern = "[object FormData]";
+  return thing && (typeof FormData === "function" && thing instanceof FormData || toString.call(thing) === pattern || isFunction(thing.toString) && thing.toString() === pattern);
+}
+var isURLSearchParams = kindOfTest("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(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  });
+  return a;
+}
+function stripBOM(content) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+}
+function inherits(constructor, superConstructor, props, descriptors2) {
+  constructor.prototype = Object.create(superConstructor.prototype, descriptors2);
+  constructor.prototype.constructor = constructor;
+  props && Object.assign(constructor.prototype, props);
+}
+function toFlatObject(sourceObj, destObj, filter) {
+  var props;
+  var i;
+  var prop;
+  var merged = {};
+  destObj = destObj || {};
+  do {
+    props = Object.getOwnPropertyNames(sourceObj);
+    i = props.length;
+    while (i-- > 0) {
+      prop = props[i];
+      if (!merged[prop]) {
+        destObj[prop] = sourceObj[prop];
+        merged[prop] = true;
+      }
+    }
+    sourceObj = Object.getPrototypeOf(sourceObj);
+  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
+  return destObj;
+}
+function endsWith(str, searchString, position) {
+  str = String(str);
+  if (position === void 0 || position > str.length) {
+    position = str.length;
+  }
+  position -= searchString.length;
+  var lastIndex = str.indexOf(searchString, position);
+  return lastIndex !== -1 && lastIndex === position;
+}
+function toArray(thing) {
+  if (!thing) return null;
+  var i = thing.length;
+  if (isUndefined(i)) return null;
+  var arr = new Array(i);
+  while (i-- > 0) {
+    arr[i] = thing[i];
+  }
+  return arr;
+}
+var isTypedArray = function (TypedArray) {
+  return function (thing) {
+    return TypedArray && thing instanceof TypedArray;
+  };
+}(typeof Uint8Array !== "undefined" && Object.getPrototypeOf(Uint8Array));
+var utils = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isStandardBrowserEnv,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM,
+  inherits,
+  toFlatObject,
+  kindOf,
+  kindOfTest,
+  endsWith,
+  toArray,
+  isTypedArray,
+  isFileList
+};
+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 = function buildURL2(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (utils.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    utils.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (utils.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      utils.forEach(val, function parseValue(v) {
+        if (utils.isDate(v)) {
+          v = v.toISOString();
+        } else if (utils.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;
+};
+function InterceptorManager() {
+  this.handlers = [];
+}
+InterceptorManager.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.prototype.eject = function eject(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager.prototype.forEach = function forEach2(fn) {
+  utils.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+var InterceptorManager_1 = InterceptorManager;
+var normalizeHeaderName = function normalizeHeaderName2(headers, normalizedName) {
+  utils.forEach(headers, function processHeader(value, name) {
+    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+      headers[normalizedName] = value;
+      delete headers[name];
+    }
+  });
+};
+function AxiosError(message, code, config, request2, response) {
+  Error.call(this);
+  this.message = message;
+  this.name = "AxiosError";
+  code && (this.code = code);
+  config && (this.config = config);
+  request2 && (this.request = request2);
+  response && (this.response = response);
+}
+utils.inherits(AxiosError, Error, {
+  toJSON: function toJSON() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: this.config,
+      code: this.code,
+      status: this.response && this.response.status ? this.response.status : null
+    };
+  }
+});
+var prototype = AxiosError.prototype;
+var descriptors = {};
+["ERR_BAD_OPTION_VALUE", "ERR_BAD_OPTION", "ECONNABORTED", "ETIMEDOUT", "ERR_NETWORK", "ERR_FR_TOO_MANY_REDIRECTS", "ERR_DEPRECATED", "ERR_BAD_RESPONSE", "ERR_BAD_REQUEST", "ERR_CANCELED"
+// eslint-disable-next-line func-names
+].forEach(function (code) {
+  descriptors[code] = {
+    value: code
+  };
+});
+Object.defineProperties(AxiosError, descriptors);
+Object.defineProperty(prototype, "isAxiosError", {
+  value: true
+});
+AxiosError.from = function (error2, code, config, request2, response, customProps) {
+  var axiosError = Object.create(prototype);
+  utils.toFlatObject(error2, axiosError, function filter(obj) {
+    return obj !== Error.prototype;
+  });
+  AxiosError.call(axiosError, error2.message, code, config, request2, response);
+  axiosError.name = error2.name;
+  customProps && Object.assign(axiosError, customProps);
+  return axiosError;
+};
+var AxiosError_1 = AxiosError;
+var transitional = {
+  silentJSONParsing: true,
+  forcedJSONParsing: true,
+  clarifyTimeoutError: false
+};
+function toFormData(obj, formData) {
+  formData = formData || new FormData();
+  var stack = [];
+  function convertValue(value) {
+    if (value === null) return "";
+    if (utils.isDate(value)) {
+      return value.toISOString();
+    }
+    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {
+      return typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
+    }
+    return value;
+  }
+  function build(data2, parentKey) {
+    if (utils.isPlainObject(data2) || utils.isArray(data2)) {
+      if (stack.indexOf(data2) !== -1) {
+        throw Error("Circular reference detected in " + parentKey);
+      }
+      stack.push(data2);
+      utils.forEach(data2, function each(value, key) {
+        if (utils.isUndefined(value)) return;
+        var fullKey = parentKey ? parentKey + "." + key : key;
+        var arr;
+        if (value && !parentKey && typeof value === "object") {
+          if (utils.endsWith(key, "{}")) {
+            value = JSON.stringify(value);
+          } else if (utils.endsWith(key, "[]") && (arr = utils.toArray(value))) {
+            arr.forEach(function (el) {
+              !utils.isUndefined(el) && formData.append(fullKey, convertValue(el));
+            });
+            return;
+          }
+        }
+        build(value, fullKey);
+      });
+      stack.pop();
+    } else {
+      formData.append(parentKey, convertValue(data2));
+    }
+  }
+  build(obj);
+  return formData;
+}
+var toFormData_1 = toFormData;
+var settle = function settle2(resolve, reject, response) {
+  var validateStatus2 = response.config.validateStatus;
+  if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
+    resolve(response);
+  } else {
+    reject(new AxiosError_1("Request failed with status code " + response.status, [AxiosError_1.ERR_BAD_REQUEST, AxiosError_1.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], response.config, response.request, response));
+  }
+};
+var cookies = utils.isStandardBrowserEnv() ?
+// Standard browser envs support document.cookie
+function standardBrowserEnv() {
+  return {
+    write: function write(name, value, expires, path, domain, secure) {
+      var cookie = [];
+      cookie.push(name + "=" + encodeURIComponent(value));
+      if (utils.isNumber(expires)) {
+        cookie.push("expires=" + new Date(expires).toGMTString());
+      }
+      if (utils.isString(path)) {
+        cookie.push("path=" + path);
+      }
+      if (utils.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);
+    }
+  };
+}() :
+// Non standard browser env (web workers, react-native) lack needed support.
+function nonStandardBrowserEnv() {
+  return {
+    write: function write() {},
+    read: function read() {
+      return null;
+    },
+    remove: function remove() {}
+  };
+}();
+var isAbsoluteURL = function isAbsoluteURL2(url) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+};
+var combineURLs = function combineURLs2(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+};
+var buildFullPath = function buildFullPath2(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL(requestedURL)) {
+    return combineURLs(baseURL, requestedURL);
+  }
+  return requestedURL;
+};
+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 = function parseHeaders2(headers) {
+  var parsed = {};
+  var key;
+  var val;
+  var i;
+  if (!headers) {
+    return parsed;
+  }
+  utils.forEach(headers.split("\n"), function parser(line) {
+    i = line.indexOf(":");
+    key = utils.trim(line.substr(0, i)).toLowerCase();
+    val = utils.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 isURLSameOrigin = utils.isStandardBrowserEnv() ?
+// Standard browser envs have full support of the APIs needed to test
+// whether the request URL is of the same origin as current location.
+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.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+    return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+  };
+}() :
+// Non standard browser envs (web workers, react-native) lack needed support.
+function nonStandardBrowserEnv2() {
+  return function isURLSameOrigin2() {
+    return true;
+  };
+}();
+function CanceledError(message) {
+  AxiosError_1.call(this, message == null ? "canceled" : message, AxiosError_1.ERR_CANCELED);
+  this.name = "CanceledError";
+}
+utils.inherits(CanceledError, AxiosError_1, {
+  __CANCEL__: true
+});
+var CanceledError_1 = CanceledError;
+var parseProtocol = function parseProtocol2(url) {
+  var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+  return match && match[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.isFormData(requestData) && utils.isStandardBrowserEnv()) {
+      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 = buildFullPath(config.baseURL, config.url);
+    request2.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+    request2.timeout = config.timeout;
+    function onloadend() {
+      if (!request2) {
+        return;
+      }
+      var responseHeaders = "getAllResponseHeaders" in request2 ? parseHeaders(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
+      };
+      settle(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(new AxiosError_1("Request aborted", AxiosError_1.ECONNABORTED, config, request2));
+      request2 = null;
+    };
+    request2.onerror = function handleError() {
+      reject(new AxiosError_1("Network Error", AxiosError_1.ERR_NETWORK, config, request2, request2));
+      request2 = null;
+    };
+    request2.ontimeout = function handleTimeout() {
+      var timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
+      var transitional$1 = config.transitional || transitional;
+      if (config.timeoutErrorMessage) {
+        timeoutErrorMessage = config.timeoutErrorMessage;
+      }
+      reject(new AxiosError_1(timeoutErrorMessage, transitional$1.clarifyTimeoutError ? AxiosError_1.ETIMEDOUT : AxiosError_1.ECONNABORTED, config, request2));
+      request2 = null;
+    };
+    if (utils.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.forEach(requestHeaders, function setRequestHeader(val, key) {
+        if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+          delete requestHeaders[key];
+        } else {
+          request2.setRequestHeader(key, val);
+        }
+      });
+    }
+    if (!utils.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 CanceledError_1() : 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;
+    }
+    var protocol = parseProtocol(fullPath);
+    if (protocol && ["http", "https", "file"].indexOf(protocol) === -1) {
+      reject(new AxiosError_1("Unsupported protocol " + protocol + ":", AxiosError_1.ERR_BAD_REQUEST, config));
+      return;
+    }
+    request2.send(requestData);
+  });
+};
+var _null = null;
+var DEFAULT_CONTENT_TYPE = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function setContentTypeIfUnset(headers, value) {
+  if (!utils.isUndefined(headers) && utils.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.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError") {
+        throw e;
+      }
+    }
+  }
+  return (encoder || JSON.stringify)(rawValue);
+}
+var defaults = {
+  transitional,
+  adapter: getDefaultAdapter(),
+  transformRequest: [function transformRequest(data2, headers) {
+    normalizeHeaderName(headers, "Accept");
+    normalizeHeaderName(headers, "Content-Type");
+    if (utils.isFormData(data2) || utils.isArrayBuffer(data2) || utils.isBuffer(data2) || utils.isStream(data2) || utils.isFile(data2) || utils.isBlob(data2)) {
+      return data2;
+    }
+    if (utils.isArrayBufferView(data2)) {
+      return data2.buffer;
+    }
+    if (utils.isURLSearchParams(data2)) {
+      setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+      return data2.toString();
+    }
+    var isObjectPayload = utils.isObject(data2);
+    var contentType = headers && headers["Content-Type"];
+    var isFileList2;
+    if ((isFileList2 = utils.isFileList(data2)) || isObjectPayload && contentType === "multipart/form-data") {
+      var _FormData = this.env && this.env.FormData;
+      return toFormData_1(isFileList2 ? {
+        "files[]": data2
+      } : data2, _FormData && new _FormData());
+    } else if (isObjectPayload || contentType === "application/json") {
+      setContentTypeIfUnset(headers, "application/json");
+      return stringifySafely(data2);
+    }
+    return data2;
+  }],
+  transformResponse: [function transformResponse(data2) {
+    var transitional3 = this.transitional || defaults.transitional;
+    var silentJSONParsing = transitional3 && transitional3.silentJSONParsing;
+    var forcedJSONParsing = transitional3 && transitional3.forcedJSONParsing;
+    var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+    if (strictJSONParsing || forcedJSONParsing && utils.isString(data2) && data2.length) {
+      try {
+        return JSON.parse(data2);
+      } catch (e) {
+        if (strictJSONParsing) {
+          if (e.name === "SyntaxError") {
+            throw AxiosError_1.from(e, AxiosError_1.ERR_BAD_RESPONSE, this, null, this.response);
+          }
+          throw e;
+        }
+      }
+    }
+    return data2;
+  }],
+  /**
+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
+   * timeout is not created.
+   */
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  env: {
+    FormData: _null
+  },
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  },
+  headers: {
+    common: {
+      Accept: "application/json, text/plain, */*"
+    }
+  }
+};
+utils.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+  defaults.headers[method] = {};
+});
+utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+});
+var defaults_1 = defaults;
+var transformData = function transformData2(data2, headers, fns) {
+  var context = this || defaults_1;
+  utils.forEach(fns, function transform(fn) {
+    data2 = fn.call(context, data2, headers);
+  });
+  return data2;
+};
+var isCancel = function isCancel2(value) {
+  return !!(value && value.__CANCEL__);
+};
+function throwIfCancellationRequested(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
+  }
+  if (config.signal && config.signal.aborted) {
+    throw new CanceledError_1();
+  }
+}
+var dispatchRequest = function dispatchRequest2(config) {
+  throwIfCancellationRequested(config);
+  config.headers = config.headers || {};
+  config.data = transformData.call(config, config.data, config.headers, config.transformRequest);
+  config.headers = utils.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
+  utils.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 = transformData.call(config, response.data, response.headers, config.transformResponse);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel(reason)) {
+      throwIfCancellationRequested(config);
+      if (reason && reason.response) {
+        reason.response.data = transformData.call(config, reason.response.data, reason.response.headers, config.transformResponse);
+      }
+    }
+    return Promise.reject(reason);
+  });
+};
+var mergeConfig = function mergeConfig2(config1, config2) {
+  config2 = config2 || {};
+  var config = {};
+  function getMergedValue(target, source2) {
+    if (utils.isPlainObject(target) && utils.isPlainObject(source2)) {
+      return utils.merge(target, source2);
+    } else if (utils.isPlainObject(source2)) {
+      return utils.merge({}, source2);
+    } else if (utils.isArray(source2)) {
+      return source2.slice();
+    }
+    return source2;
+  }
+  function mergeDeepProperties(prop) {
+    if (!utils.isUndefined(config2[prop])) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (!utils.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function valueFromConfig2(prop) {
+    if (!utils.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    }
+  }
+  function defaultToConfig2(prop) {
+    if (!utils.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    } else if (!utils.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,
+    beforeRedirect: defaultToConfig2,
+    transport: defaultToConfig2,
+    httpAgent: defaultToConfig2,
+    httpsAgent: defaultToConfig2,
+    cancelToken: defaultToConfig2,
+    socketPath: defaultToConfig2,
+    responseEncoding: defaultToConfig2,
+    validateStatus: mergeDirectKeys
+  };
+  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
+    var merge2 = mergeMap[prop] || mergeDeepProperties;
+    var configValue = merge2(prop);
+    utils.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
+  });
+  return config;
+};
+var data = {
+  version: "0.27.2"
+};
+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 transitional2(validator2, version, 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 AxiosError_1(formatMessage(opt, " has been removed" + (version ? " in " + version : "")), AxiosError_1.ERR_DEPRECATED);
+    }
+    if (version && !deprecatedWarnings[opt]) {
+      deprecatedWarnings[opt] = true;
+    }
+    return validator2 ? validator2(value, opt, opts) : true;
+  };
+};
+function assertOptions(options, schema, allowUnknown) {
+  if (typeof options !== "object") {
+    throw new AxiosError_1("options must be an object", AxiosError_1.ERR_BAD_OPTION_VALUE);
+  }
+  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 AxiosError_1("option " + opt + " must be " + result, AxiosError_1.ERR_BAD_OPTION_VALUE);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw new AxiosError_1("Unknown option " + opt, AxiosError_1.ERR_BAD_OPTION);
+    }
+  }
+}
+var validator = {
+  assertOptions,
+  validators: validators$1
+};
+var validators = validator.validators;
+function Axios(instanceConfig) {
+  this.defaults = instanceConfig;
+  this.interceptors = {
+    request: new InterceptorManager_1(),
+    response: new InterceptorManager_1()
+  };
+}
+Axios.prototype.request = function request(configOrUrl, config) {
+  if (typeof configOrUrl === "string") {
+    config = config || {};
+    config.url = configOrUrl;
+  } else {
+    config = configOrUrl || {};
+  }
+  config = mergeConfig(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 transitional3 = config.transitional;
+  if (transitional3 !== void 0) {
+    validator.assertOptions(transitional3, {
+      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 = [dispatchRequest, 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 (error2) {
+      onRejected(error2);
+      break;
+    }
+  }
+  try {
+    promise = dispatchRequest(newConfig);
+  } catch (error2) {
+    return Promise.reject(error2);
+  }
+  while (responseInterceptorChain.length) {
+    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+  }
+  return promise;
+};
+Axios.prototype.getUri = function getUri(config) {
+  config = mergeConfig(this.defaults, config);
+  var fullPath = buildFullPath(config.baseURL, config.url);
+  return buildURL(fullPath, config.params, config.paramsSerializer);
+};
+utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData2(method) {
+  Axios.prototype[method] = function (url, config) {
+    return this.request(mergeConfig(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+utils.forEach(["post", "put", "patch"], function forEachMethodWithData2(method) {
+  function generateHTTPMethod(isForm) {
+    return function httpMethod(url, data2, config) {
+      return this.request(mergeConfig(config || {}, {
+        method,
+        headers: isForm ? {
+          "Content-Type": "multipart/form-data"
+        } : {},
+        url,
+        data: data2
+      }));
+    };
+  }
+  Axios.prototype[method] = generateHTTPMethod();
+  Axios.prototype[method + "Form"] = generateHTTPMethod(true);
+});
+var Axios_1 = Axios;
+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 CanceledError_1(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 isAxiosError = function isAxiosError2(payload) {
+  return utils.isObject(payload) && payload.isAxiosError === true;
+};
+function createInstance(defaultConfig) {
+  var context = new Axios_1(defaultConfig);
+  var instance = bind(Axios_1.prototype.request, context);
+  utils.extend(instance, Axios_1.prototype, context);
+  utils.extend(instance, context);
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig(defaultConfig, instanceConfig));
+  };
+  return instance;
+}
+var axios$1 = createInstance(defaults_1);
+axios$1.Axios = Axios_1;
+axios$1.CanceledError = CanceledError_1;
+axios$1.CancelToken = CancelToken_1;
+axios$1.isCancel = isCancel;
+axios$1.VERSION = data.version;
+axios$1.toFormData = toFormData_1;
+axios$1.AxiosError = AxiosError_1;
+axios$1.Cancel = axios$1.CanceledError;
+axios$1.all = function all(promises) {
+  return Promise.all(promises);
+};
+axios$1.spread = spread;
+axios$1.isAxiosError = isAxiosError;
+var axios_1 = axios$1;
+var _default = axios$1;
+axios_1.default = _default;
+var axios = axios_1;
 class RTCEndpoint extends Event$1 {
   constructor(options) {
     super("RTCPusherPlayer");
     this.TAG = "[RTCPusherPlayer]";
-    let defaults = {
+    let defaults2 = {
       element: "",
       // html video element
       debug: false,
@@ -4816,9 +5974,10 @@ class RTCEndpoint extends Event$1 {
       resolution: {
         w: 0,
         h: 0
-      }
+      },
+      usedatachannel: false
     };
-    this.options = Object.assign({}, defaults, options);
+    this.options = Object.assign({}, defaults2, options);
     if (this.options.debug) {
       setLogger();
     }
@@ -4826,15 +5985,28 @@ class RTCEndpoint extends Event$1 {
       onicecandidate: this._onIceCandidate.bind(this),
       ontrack: this._onTrack.bind(this),
       onicecandidateerror: this._onIceCandidateError.bind(this),
-      onconnectionstatechange: this._onconnectionstatechange.bind(this)
+      onconnectionstatechange: this._onconnectionstatechange.bind(this),
+      ondatachannelopen: this._onDataChannelOpen.bind(this),
+      ondatachannelmsg: this._onDataChannelMsg.bind(this),
+      ondatachannelerr: this._onDataChannelErr.bind(this),
+      ondatachannelclose: this._onDataChannelClose.bind(this)
     };
     this._remoteStream = null;
     this._localStream = null;
+    this._tracks = [];
     this.pc = new RTCPeerConnection(null);
     this.pc.onicecandidate = this.e.onicecandidate;
     this.pc.onicecandidateerror = this.e.onicecandidateerror;
     this.pc.ontrack = this.e.ontrack;
     this.pc.onconnectionstatechange = this.e.onconnectionstatechange;
+    this.datachannel = null;
+    if (this.options.usedatachannel) {
+      this.datachannel = this.pc.createDataChannel("chat");
+      this.datachannel.onclose = this.e.ondatachannelclose;
+      this.datachannel.onerror = this.e.ondatachannelerr;
+      this.datachannel.onmessage = this.e.ondatachannelmsg;
+      this.datachannel.onopen = this.e.ondatachannelopen;
+    }
     if (!this.options.recvOnly && (this.options.audioEnable || this.options.videoEnable)) this.start();else this.receive();
   }
   receive() {
@@ -4846,32 +6018,37 @@ class RTCEndpoint extends Event$1 {
       direction: "recvonly",
       sendEncodings: []
     };
-    this.pc.addTransceiver("audio", AudioTransceiverInit);
-    this.pc.addTransceiver("video", VideoTransceiverInit);
+    if (this.options.videoEnable) {
+      this.pc.addTransceiver("video", VideoTransceiverInit);
+    }
+    if (this.options.audioEnable) {
+      this.pc.addTransceiver("audio", AudioTransceiverInit);
+    }
     this.pc.createOffer().then(desc => {
       log(this.TAG, "offer:", desc.sdp);
       this.pc.setLocalDescription(desc).then(() => {
-        fetch(this.options.zlmsdpUrl, {
-          method: "POST",
-          body: desc.sdp,
+        axios({
+          method: "post",
+          url: this.options.zlmsdpUrl,
+          responseType: "json",
+          data: desc.sdp,
           headers: {
             "Content-Type": "text/plain;charset=utf-8"
           }
         }).then(response => {
-          response.json().then(data => {
-            if (data.code != 0) {
-              this.dispatch(Events$1.WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED, data);
-              return;
-            }
-            let anwser = {};
-            anwser.sdp = data.sdp;
-            anwser.type = "answer";
-            log(this.TAG, "answer:", data.sdp);
-            this.pc.setRemoteDescription(anwser).then(() => {
-              log(this.TAG, "set remote sucess");
-            }).catch(e => {
-              error(this.TAG, e);
-            });
+          let ret = response.data;
+          if (ret.code != 0) {
+            this.dispatch(Events$1.WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED, ret);
+            return;
+          }
+          let anwser = {};
+          anwser.sdp = ret.sdp;
+          anwser.type = "answer";
+          log(this.TAG, "answer:", ret.sdp);
+          this.pc.setRemoteDescription(anwser).then(() => {
+            log(this.TAG, "set remote sucess");
+          }).catch(e => {
+            error(this.TAG, e);
           });
         });
       });
@@ -4926,64 +6103,76 @@ class RTCEndpoint extends Event$1 {
           scaleResolutionDownBy: 4
         }];
       }
-      if (stream.getAudioTracks().length > 0) {
-        this.pc.addTransceiver(stream.getAudioTracks()[0], AudioTransceiverInit);
-      } else {
-        AudioTransceiverInit.direction = "recvonly";
-        this.pc.addTransceiver("audio", AudioTransceiverInit);
+      if (this.options.audioEnable) {
+        if (stream.getAudioTracks().length > 0) {
+          this.pc.addTransceiver(stream.getAudioTracks()[0], AudioTransceiverInit);
+        } else {
+          AudioTransceiverInit.direction = "recvonly";
+          this.pc.addTransceiver("audio", AudioTransceiverInit);
+        }
       }
-      if (stream.getVideoTracks().length > 0) {
-        this.pc.addTransceiver(stream.getVideoTracks()[0], VideoTransceiverInit);
-      } else {
-        VideoTransceiverInit.direction = "recvonly";
-        this.pc.addTransceiver("video", VideoTransceiverInit);
+      if (this.options.videoEnable) {
+        if (stream.getVideoTracks().length > 0) {
+          this.pc.addTransceiver(stream.getVideoTracks()[0], VideoTransceiverInit);
+        } else {
+          VideoTransceiverInit.direction = "recvonly";
+          this.pc.addTransceiver("video", VideoTransceiverInit);
+        }
       }
       this.pc.createOffer().then(desc => {
         log(this.TAG, "offer:", desc.sdp);
         this.pc.setLocalDescription(desc).then(() => {
-          fetch(this.options.zlmsdpUrl, {
-            method: "POST",
+          axios({
+            method: "post",
+            url: this.options.zlmsdpUrl,
+            responseType: "json",
+            data: desc.sdp,
             headers: {
               "Content-Type": "text/plain;charset=utf-8"
-            },
-            body: desc.sdp
+            }
           }).then(response => {
-            response.json().then(ret => {
-              if (ret.code != 0) {
-                this.dispatch(Events$1.WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED, ret);
-                return;
-              }
-              let anwser = {};
-              anwser.sdp = ret.sdp;
-              anwser.type = "answer";
-              log(this.TAG, "answer:", ret.sdp);
-              this.pc.setRemoteDescription(anwser).then(() => {
-                log(this.TAG, "set remote sucess");
-              }).catch(e => {
-                error(this.TAG, e);
-              });
+            let ret = response.data;
+            if (ret.code != 0) {
+              this.dispatch(Events$1.WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED, ret);
+              return;
+            }
+            let anwser = {};
+            anwser.sdp = ret.sdp;
+            anwser.type = "answer";
+            log(this.TAG, "answer:", ret.sdp);
+            this.pc.setRemoteDescription(anwser).then(() => {
+              log(this.TAG, "set remote sucess");
+            }).catch(e => {
+              error(this.TAG, e);
             });
           });
-        }).catch(e => {
-          error(this.TAG, e);
         });
       }).catch(e => {
-        this.dispatch(Events$1.CAPTURE_STREAM_FAILED);
+        error(this.TAG, e);
       });
+    }).catch(e => {
+      this.dispatch(Events$1.CAPTURE_STREAM_FAILED);
     });
   }
   _onIceCandidate(event) {
     if (event.candidate) {
-      log("Remote ICE candidate: \n " + event.candidate.candidate);
+      log(this.TAG, "Remote ICE candidate: \n " + event.candidate.candidate);
     }
   }
   _onTrack(event) {
+    this._tracks.push(event.track);
     if (this.options.element && event.streams && event.streams.length > 0) {
       this.options.element.srcObject = event.streams[0];
       this._remoteStream = event.streams[0];
       this.dispatch(Events$1.WEBRTC_ON_REMOTE_STREAMS, event);
     } else {
-      error("element pararm is failed");
+      if (this.pc.getReceivers().length == this._tracks.length) {
+        log(this.TAG, "play remote stream ");
+        this._remoteStream = new MediaStream(this._tracks);
+        this.options.element.srcObject = this._remoteStream;
+      } else {
+        error(this.TAG, "wait stream track finish");
+      }
     }
   }
   _onIceCandidateError(event) {
@@ -4992,7 +6181,37 @@ class RTCEndpoint extends Event$1 {
   _onconnectionstatechange(event) {
     this.dispatch(Events$1.WEBRTC_ON_CONNECTION_STATE_CHANGE, this.pc.connectionState);
   }
+  _onDataChannelOpen(event) {
+    log(this.TAG, "ondatachannel open:", event);
+    this.dispatch(Events$1.WEBRTC_ON_DATA_CHANNEL_OPEN, event);
+  }
+  _onDataChannelMsg(event) {
+    log(this.TAG, "ondatachannel msg:", event);
+    this.dispatch(Events$1.WEBRTC_ON_DATA_CHANNEL_MSG, event);
+  }
+  _onDataChannelErr(event) {
+    log(this.TAG, "ondatachannel err:", event);
+    this.dispatch(Events$1.WEBRTC_ON_DATA_CHANNEL_ERR, event);
+  }
+  _onDataChannelClose(event) {
+    log(this.TAG, "ondatachannel close:", event);
+    this.dispatch(Events$1.WEBRTC_ON_DATA_CHANNEL_CLOSE, event);
+  }
+  sendMsg(data2) {
+    if (this.datachannel != null) {
+      this.datachannel.send(data2);
+    } else {
+      error(this.TAG, "data channel is null");
+    }
+  }
+  closeDataChannel() {
+    if (this.datachannel) {
+      this.datachannel.close();
+      this.datachannel = null;
+    }
+  }
   close() {
+    this.closeDataChannel();
     if (this.pc) {
       this.pc.close();
       this.pc = null;
@@ -5010,6 +6229,10 @@ class RTCEndpoint extends Event$1 {
         track.stop();
       });
     }
+    this._tracks.forEach((track, idx) => {
+      track.stop();
+    });
+    this._tracks = [];
   }
   get remoteStream() {
     return this._remoteStream;
@@ -5129,7 +6352,9 @@ class WebRtcMt$1 {
       this.log("warn", "ICE \u534F\u5546\u51FA\u9519");
       this.rePlay(videoElm);
     });
-    player.on(Events.WEBRTC_ON_REMOTE_STREAMS, e => {});
+    player.on(Events.WEBRTC_ON_REMOTE_STREAMS, e => {
+      this.log("warn", "\u83B7\u53D6\u5230\u4E86\u8FDC\u7AEF\u6D41\uFF0C\u53EF\u4EE5\u64AD\u653E");
+    });
     player.on(Events.WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED, e => {
       this.log("warn", `offer anwser \u4EA4\u6362\u5931\u8D25\uFF0C\u83B7\u53D6\u89C6\u9891\u6D41\u5931\u8D25, ${e}`);
       this.rePlay(videoElm);