function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _construct(Parent, args, Class) {
  if (_isNativeReflectConstruct()) {
    _construct = Reflect.construct;
  } else {
    _construct = function _construct(Parent, args, Class) {
      var a = [null];
      a.push.apply(a, args);
      var Constructor = Function.bind.apply(Parent, a);
      var instance = new Constructor();
      if (Class) _setPrototypeOf(instance, Class.prototype);
      return instance;
    };
  }

  return _construct.apply(null, arguments);
}

function _isNativeFunction(fn) {
  return Function.toString.call(fn).indexOf("[native code]") !== -1;
}

function _wrapNativeSuper(Class) {
  var _cache = typeof Map === "function" ? new Map() : undefined;

  _wrapNativeSuper = function _wrapNativeSuper(Class) {
    if (Class === null || !_isNativeFunction(Class)) return Class;

    if (typeof Class !== "function") {
      throw new TypeError("Super expression must either be null or a function");
    }

    if (typeof _cache !== "undefined") {
      if (_cache.has(Class)) return _cache.get(Class);

      _cache.set(Class, Wrapper);
    }

    function Wrapper() {
      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
    }

    Wrapper.prototype = Object.create(Class.prototype, {
      constructor: {
        value: Wrapper,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    return _setPrototypeOf(Wrapper, Class);
  };

  return _wrapNativeSuper(Class);
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function _possibleConstructorReturn(self, call) {
  if (call && (typeof call === "object" || typeof call === "function")) {
    return call;
  }

  return _assertThisInitialized(self);
}

function _createSuper(Derived) {
  var hasNativeReflectConstruct = _isNativeReflectConstruct();

  return function _createSuperInternal() {
    var Super = _getPrototypeOf(Derived),
        result;

    if (hasNativeReflectConstruct) {
      var NewTarget = _getPrototypeOf(this).constructor;

      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }

    return _possibleConstructorReturn(this, result);
  };
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor) n = o.constructor.name;
  if (n === "Map" || n === "Set") return Array.from(o);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}

function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length;

  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

  return arr2;
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

var _toString = Object.prototype.toString;
/**
 * 对字符串进行编码转换
 *
 * @param str 字符串
 */

function encode(str) {
  return encodeURIComponent(str).replace(/%40/gi, '@').replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');
}
/**
 * 是不是一个日期对象
 *
 * @param date 判断目标
 */

function isDate(date) {
  return _toString.call(date) === '[object Date]';
}
/**
 * 是不是一个普通对象
 *
 * @param obj 判断目标
 */

function isPlainObject(obj) {
  return _toString.call(obj) === '[object Object]';
}
/**
 * 深度合并多个对象
 *
 * @param objs n 个对象
 */

function deepMerge() {
  var result = {};

  function assignValue(key, val) {
    // 如果当前结果和当前值都为普通对象
    // 递归进行深度合并
    if (isPlainObject(result[key]) && isPlainObject(val)) {
      result[key] = deepMerge(result[key], val);
    } // 如果只有当前值为普通对象
    // 直接深拷贝当前值
    else if (isPlainObject(val)) {
        result[key] = deepMerge({}, val);
      } // 如果都不是普通对象
      // 直接赋值
      else {
          result[key] = val;
        }
  }

  for (var _len = arguments.length, objs = new Array(_len), _key = 0; _key < _len; _key++) {
    objs[_key] = arguments[_key];
  }

  objs.forEach(function assignObj(obj) {
    Object.entries(obj).forEach(function assignKey(_ref) {
      var _ref2 = _slicedToArray(_ref, 2),
          key = _ref2[0],
          value = _ref2[1];

      assignValue(key, value);
    });
  });
  return result;
}
/**
 * 从对象中提取一部分属性
 *
 * @param obj  源对象
 * @param keys 需要提取的 key
 */

function pick(obj) {
  var _pick = {};

  for (var _len2 = arguments.length, keys = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
    keys[_key2 - 1] = arguments[_key2];
  }

  keys.forEach(function pickKey(key) {
    _pick[key] = obj[key];
  });
  return _pick;
}
/**
 * 从对象中剔除一部分属性
 *
 * @param obj  源对象
 * @param keys 需要剔除的 key
 */

function omit(obj) {
  var _omit = _objectSpread2({}, obj);

  for (var _len3 = arguments.length, keys = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
    keys[_key3 - 1] = arguments[_key3];
  }

  keys.forEach(function omitKey(key) {
    delete _omit[key];
  });
  return _omit;
}

/**
 * 通过请求地址和序列化参数生成新的请求地址
 *
 * @param url              请求地址
 * @param serializedParams 序列化参数
 */

function generateURL(url, serializedParams) {
  // 移除 hash
  var hashIndex = url.indexOf('#');

  if (hashIndex !== -1) {
    url = url.slice(0, hashIndex);
  }

  if (serializedParams === '') {
    return url;
  } // 拼接前缀


  var prefix = url.indexOf('?') === -1 ? '?' : '&';
  serializedParams = "".concat(prefix).concat(serializedParams);
  return "".concat(url).concat(serializedParams);
}
/**
 * 默认参数序列化
 *
 * @param params 请求参数
 */


function paramsSerialization(params) {
  var parts = [];
  Object.entries(params).forEach(function encodeKeyValue(_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        key = _ref2[0],
        value = _ref2[1];

    if (value === null || value === void 0 || value !== value) {
      return;
    } // 如果值是一个数组, 则特殊处理 key


    if (Array.isArray(value)) {
      key += '[]';
    } // 转成数组统一处理


    var values = [].concat(value);
    values.forEach(function (val) {
      if (isPlainObject(val)) {
        val = JSON.stringify(val);
      } else if (isDate(val)) {
        val = val.toISOString();
      }

      parts.push("".concat(encode(key), "=").concat(encode(val)));
    });
  });
  return parts.join('&');
}
/**
 * 处理 URL 参数
 *
 * @param url              请求地址
 * @param params           请求参数
 * @param paramsSerializer 自定义参数序列化
 */


function buildURL(url) {
  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var paramsSerializer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : paramsSerialization;
  return generateURL(url, paramsSerializer(params));
}

/**
 * 只取 config2 中的配置
 *
 * @param keys
 * @param config
 * @param config2
 */

function onlyFromConfig2(keys, config, config2) {
  keys.forEach(function (key) {
    if (config2[key] !== void 0) {
      config[key] = config2[key];
    }
  });
}
/**
 * 优先取 config2 中的配置, config2 中没有就取 config1
 *
 * @param keys
 * @param config
 * @param config1
 * @param config2
 */


function priorityFromConfig2(keys, config, config1, config2) {
  keys.forEach(function (key) {
    if (config2[key] !== void 0) {
      config[key] = config2[key];
    } else if (config1[key] !== void 0) {
      config[key] = config1[key];
    }
  });
}
/**
 * 深度合并配置
 *
 * @param keys
 * @param config
 * @param config1
 * @param config2
 */


function deepMergeConfig(keys, config, config1, config2) {
  keys.forEach(function (key) {
    if (isPlainObject(config2[key])) {
      var _config1$key;

      config[key] = deepMerge((_config1$key = config1[key]) !== null && _config1$key !== void 0 ? _config1$key : {}, config2[key]);
    } else if (isPlainObject(config1[key])) {
      config[key] = deepMerge(config1[key]);
    }
  });
}
/**
 * 合并 Axios 请求配置
 *
 * @param config1 Axios 请求配置1
 * @param config2 Axios 请求配置2
 */


function mergeConfig() {
  var config1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var config2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var config = {};
  var onlyFromConfig2Keys = ['url', 'data'];
  var priorityFromConfig2Keys = ['adapter', 'baseURL', 'method', 'validateStatus', 'paramsSerializer', 'transformRequest', 'transformResponse', 'errorHandler', 'cancelToken', 'dataType', 'responseType', 'timeout', 'enableHttp2', 'enableQuic', 'enableCache', 'sslVerify'];
  var deepMergeConfigKeys = ['headers', 'params'];
  onlyFromConfig2(onlyFromConfig2Keys, config, config2);
  priorityFromConfig2(priorityFromConfig2Keys, config, config1, config2);
  deepMergeConfig(deepMergeConfigKeys, config, config1, config2);
  return config;
}

/**
 * 拦截器管理器
 */
var InterceptorManagerClass = /*#__PURE__*/function () {
  function InterceptorManagerClass() {
    _classCallCheck(this, InterceptorManagerClass);

    /**
     * 生成拦截器 id
     */
    this._id = 0;
    /**
     * 拦截器集合
     */

    this._interceptors = {};
  }

  _createClass(InterceptorManagerClass, [{
    key: "use",
    value: function use(resolved, rejected) {
      this._interceptors[++this._id] = {
        resolved: resolved,
        rejected: rejected
      };
      return this._id;
    }
  }, {
    key: "eject",
    value: function eject(id) {
      delete this._interceptors[id];
    }
  }, {
    key: "forEach",
    value: function forEach(executor, reverse) {
      var interceptors = Object.values(this._interceptors);

      if (reverse === 'reverse') {
        interceptors = interceptors.reverse();
      }

      interceptors.forEach(executor);
    }
  }]);

  return InterceptorManagerClass;
}();

var CancelClass = /*#__PURE__*/function () {
  /**
   * @param message 取消信息
   */
  function CancelClass(message) {
    _classCallCheck(this, CancelClass);

    this.message = message;
  }

  _createClass(CancelClass, [{
    key: "toString",
    value: function toString() {
      var message = this.message ? ": ".concat(this.message) : '';
      return "Cancel".concat(message);
    }
  }]);

  return CancelClass;
}();

/**
 * 是否是取消请求实例
 *
 * @param value 判断的值
 */

function isCancel(value) {
  return value instanceof CancelClass;
}

/**
 * 请求方法转全小写
 *
 * @param config Axios 请求配置
 */
function methodToLowercase() {
  var method = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'get';
  return method.toLowerCase();
}
/**
 * 请求方法转全大写
 *
 * @param config Axios 请求配置
 */

function methodToUppercase() {
  var method = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'GET';
  return method.toUpperCase();
}

/**
 * 拉平请求头
 *
 * @param config Axios 请求配置
 */

function flattenHeaders(config) {
  var _headers$common, _headers$method;

  var headers = config.headers;

  if (headers === void 0) {
    return {};
  }

  var method = methodToLowercase(config.method);
  return _objectSpread2(_objectSpread2(_objectSpread2({}, (_headers$common = headers.common) !== null && _headers$common !== void 0 ? _headers$common : {}), (_headers$method = headers[method]) !== null && _headers$method !== void 0 ? _headers$method : {}), omit(headers, 'common', 'options', 'get', 'head', 'post', 'put', 'delete', 'trace', 'connect'));
}

/**
 * 转换数据
 *
 * @param data       请求数据/响应数据
 * @param headers    请求头/响应头
 * @param transforms 请求数据转换函数/响应数据转换函数
 */
function transformData(data, headers, transforms) {
  if (transforms === void 0) {
    return data;
  }

  if (!Array.isArray(transforms)) {
    transforms = [transforms];
  }

  transforms.forEach(function (transform) {
    data = transform(data, headers);
  });
  return data;
}

/**
 * 检查是否是一个绝对 URL
 *
 * xxx:// 或者 "//" 开头,  视为绝对地址
 *
 * @param url 需要检查的 URL
 */
function isAbsoluteURL(url) {
  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
}

/**
 * 拼接 baseURL 和 url 获得完整的 URL
 *
 * combineURL('1/2///','////3/4') => '1/2/3/4'
 */
function combineURL(baseURL, url) {
  return "".concat(baseURL.replace(/\/*$/, ''), "/").concat(url.replace(/^\/*/, ''));
}

/**
 * 根据配置中的 baseURL 和 url 和 params 生成完整 URL
 *
 * @param config Axios 请求配置
 */

function transformURL(config) {
  var _config$baseURL = config.baseURL,
      baseURL = _config$baseURL === void 0 ? '' : _config$baseURL,
      _config$url = config.url,
      url = _config$url === void 0 ? '' : _config$url;
  var fullURL = isAbsoluteURL(url) ? url : combineURL(baseURL, url);
  return buildURL(fullURL, config.params, config.paramsSerializer);
}
/**
 * Axios 请求配置转换成各大平台通用请求配置
 *
 * 抹平差异
 *
 * @param config Axios 请求配置
 */


function transformRequest(config) {
  return _objectSpread2({
    url: transformURL(config),
    method: methodToUppercase(config.method),
    header: config.headers
  }, pick(config, 'data', 'headers', 'dataType', 'responseType', 'timeout', 'enableHttp2', 'enableQuic', 'enableCache', 'sslVerify'));
}

/**
 * 各大平台通用响应体转成 Axios 响应体
 *
 * 抹平差异
 *
 * @param response 通用响应体
 * @param config   Axios 请求配置
 */

function transformResponse(response, config) {
  var _ref, _response$statusCode, _ref2, _response$header;

  var status = (_ref = (_response$statusCode = response.statusCode) !== null && _response$statusCode !== void 0 ? _response$statusCode : response.status) !== null && _ref !== void 0 ? _ref : 400;
  var headers = (_ref2 = (_response$header = response.header) !== null && _response$header !== void 0 ? _response$header : response.headers) !== null && _ref2 !== void 0 ? _ref2 : {};
  var statusText = status === 200 ? 'OK' : status === 400 ? 'Bad Adapter' : '';
  return _objectSpread2({
    status: status,
    statusText: statusText,
    headers: headers,
    config: config
  }, pick(response, 'data', 'cookies', 'profile'));
}

/**
 * AxiosError 继承自 Error
 */
var AxiosErrorClass = /*#__PURE__*/function (_Error) {
  _inherits(AxiosErrorClass, _Error);

  var _super = _createSuper(AxiosErrorClass);

  /**
   * @param message  错误信息
   * @param config   Axios 请求配置
   * @param request  通用请求配置
   * @param response Axios 响应体
   */
  function AxiosErrorClass(message, config, request, response) {
    var _this;

    _classCallCheck(this, AxiosErrorClass);

    _this = _super.call(this, message);
    _this.config = config;
    _this.request = request;
    _this.response = response;
    _this.isAxiosError = true; // 修复继承系统自带类 prototype 设置失败的问题

    Object.setPrototypeOf(_assertThisInitialized(_this), AxiosErrorClass.prototype);
    return _this;
  }

  return AxiosErrorClass;
}( /*#__PURE__*/_wrapNativeSuper(Error));
/**
 * 创建 AxiosError 的工厂方法
 *
 * 返回一个新的 AxiosError 对象
 *
 * @param message  错误信息
 * @param config   Axios 请求配置
 * @param request  通用请求配置
 * @param response Axios 响应体
 */


function createError(message, config, request, response) {
  return new AxiosErrorClass(message, config, request, response);
}

/**
 * 请求函数
 *
 * @param config Axios 请求配置
 */

function request(config) {
  return new Promise(function dispatchAdapter(resolve, reject) {
    var adapter = config.adapter,
        cancelToken = config.cancelToken;
    var requestConfig = transformRequest(config);
    /**
     * 捕获错误
     *
     * @param message  错误信息
     * @param response Axios 响应体
     */

    function catchError(message, response) {
      if (typeof message !== 'string') {
        message = '配置不正确或者网络异常';
      }

      reject(createError(message, config, requestConfig, response));
    }

    if (adapter === void 0) {
      catchError('平台适配失败，您需要参阅文档使用自定义适配器手动适配当前平台');
      return;
    }
    /**
     * 效验状态码
     *
     * @param res 请求结果
     */


    function handleResponse(res) {
      var response = transformResponse(res, config);

      if (config.validateStatus === void 0 || config.validateStatus(response.status)) {
        resolve(response);
      } else {
        catchError("\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801\u4E3A ".concat(response.status), response);
      }
    } // 使用适配器发送请求


    var task = adapter(_objectSpread2(_objectSpread2({}, requestConfig), {}, {
      success: handleResponse,
      fail: catchError
    })); // 如果存在取消令牌
    // 则调用取消令牌里的 listener 监听用户的取消操作

    if (cancelToken !== void 0) {
      cancelToken.listener.then(function onCanceled(reason) {
        if (task !== void 0) {
          task.abort();
        }

        reject(reason);
      });
    }
  });
}

/**
 * 如果已经取消, 则抛出取消对象
 *
 * @param config Axios 请求配置
 */

function throwIfCancellationRequested(config) {
  if (config.cancelToken) {
    config.cancelToken.throwIfRequested();
  }
}
/**
 * 发送请求
 *
 * @param config Axios 请求配置
 */


function dispatchRequest(config) {
  var _config$data;

  throwIfCancellationRequested(config);
  config.headers = flattenHeaders(config);
  config.data = transformData((_config$data = config.data) !== null && _config$data !== void 0 ? _config$data : {}, config.headers, config.transformRequest);

  function onResolved(response) {
    throwIfCancellationRequested(config);
    response.data = transformData(response.data, response.headers, config.transformResponse);
    return response;
  }

  function onRejected(reason) {
    var _config$errorHandler, _config$errorHandler2;

    if (!isCancel(reason)) {
      throwIfCancellationRequested(config);

      if (reason.response !== void 0) {
        reason.response.data = transformData(reason.response.data, reason.response.headers, config.transformResponse);
      }
    }

    return (_config$errorHandler = (_config$errorHandler2 = config.errorHandler) === null || _config$errorHandler2 === void 0 ? void 0 : _config$errorHandler2.call(config, reason)) !== null && _config$errorHandler !== void 0 ? _config$errorHandler : Promise.reject(reason);
  }

  return request(config).then(onResolved, onRejected);
}

var AxiosClass = /*#__PURE__*/function () {
  /**
   * @param defaults 自定义默认配置
   */
  function AxiosClass() {
    var defaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    _classCallCheck(this, AxiosClass);

    this.defaults = defaults;
    this.interceptors = {
      request: new InterceptorManagerClass(),
      response: new InterceptorManagerClass()
    };
  }

  _createClass(AxiosClass, [{
    key: "getUri",
    value: function getUri(config) {
      var _mergeConfig = mergeConfig(this.defaults, config),
          _mergeConfig$url = _mergeConfig.url,
          url = _mergeConfig$url === void 0 ? '' : _mergeConfig$url,
          params = _mergeConfig.params,
          paramsSerializer = _mergeConfig.paramsSerializer;

      return buildURL(url, params, paramsSerializer).replace(/^\?/, '');
    }
  }, {
    key: "request",
    value: function request(config) {
      var requestConfig = mergeConfig(this.defaults, config);
      var promiseRequest = Promise.resolve(requestConfig); // 执行请求拦截器

      this.interceptors.request.forEach(function executor(_ref) {
        var resolved = _ref.resolved,
            rejected = _ref.rejected;
        promiseRequest = promiseRequest.then(resolved, rejected);
      }, 'reverse'); // 发送请求

      var promiseResponse = promiseRequest.then(dispatchRequest); // 执行响应拦截器

      this.interceptors.response.forEach(function executor(_ref2) {
        var resolved = _ref2.resolved,
            rejected = _ref2.rejected;
        promiseResponse = promiseResponse.then(resolved, rejected);
      });
      return promiseResponse;
    }
  }, {
    key: "options",
    value: function options(url, config) {
      return this._requestMethodWithoutParams('options', url, void 0, config);
    }
  }, {
    key: "get",
    value: function get(url, params, config) {
      return this._requestMethodWithoutParams('get', url, params, config);
    }
  }, {
    key: "head",
    value: function head(url, params, config) {
      return this._requestMethodWithoutParams('head', url, params, config);
    }
  }, {
    key: "post",
    value: function post(url, data, config) {
      return this._requestMethodWithoutData('post', url, data, config);
    }
  }, {
    key: "put",
    value: function put(url, data, config) {
      return this._requestMethodWithoutData('put', url, data, config);
    }
  }, {
    key: "delete",
    value: function _delete(url, params, config) {
      return this._requestMethodWithoutParams('delete', url, params, config);
    }
  }, {
    key: "trace",
    value: function trace(url, config) {
      return this._requestMethodWithoutParams('trace', url, void 0, config);
    }
  }, {
    key: "connect",
    value: function connect(url, config) {
      return this._requestMethodWithoutParams('connect', url, void 0, config);
    }
    /**
     * 合并配置后发送 HTTP 请求
     *
     * @param method 请求方法
     * @param url    请求地址
     * @param params 请求参数
     * @param config 额外配置
     */

  }, {
    key: "_requestMethodWithoutParams",
    value: function _requestMethodWithoutParams(method, url, params) {
      var config = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
      return this.request(_objectSpread2(_objectSpread2({}, config), {}, {
        method: method,
        url: url,
        params: params
      }));
    }
    /**
     * 合并配置后发送 HTTP 请求
     *
     * @param method 请求方法
     * @param url    请求地址
     * @param data   请求数据
     * @param config 额外配置
     */

  }, {
    key: "_requestMethodWithoutData",
    value: function _requestMethodWithoutData(method, url, data) {
      var config = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
      return this.request(_objectSpread2(_objectSpread2({}, config), {}, {
        method: method,
        url: url,
        data: data
      }));
    }
  }]);

  return AxiosClass;
}();

var CancelTokenClass = /*#__PURE__*/function () {
  function CancelTokenClass(executor) {
    var _this = this;

    _classCallCheck(this, CancelTokenClass);

    var action;
    this.listener = new Promise(function (resolve) {
      action = function action(message) {
        // 防止重复取消
        if (_this._reason) {
          return;
        }

        _this._reason = new CancelClass(message);
        resolve(_this._reason);
      };
    });
    executor(action);
  }

  _createClass(CancelTokenClass, [{
    key: "throwIfRequested",
    value: function throwIfRequested() {
      if (this._reason) {
        throw this._reason;
      }
    }
    /**
     * 返回一个 CancelTokenSource
     *
     * CancelTokenSource.token 是一个 CancelToken 对象
     *
     * CancelTokenSource.cancel 是一个 CancelAction 函数
     *
     * 调用 CancelTokenSource.cancel('这里可以填写您的错误信息')
     *
     * 取消请求 CancelTokenSource.token
     */

  }], [{
    key: "source",
    value: function source() {
      var cancel;
      var token = new CancelTokenClass(function executor(action) {
        cancel = action;
      });
      return {
        token: token,
        cancel: cancel
      };
    }
  }]);

  return CancelTokenClass;
}();

/**
 * 自适应当前平台
 */
function adaptive() {
  var stack = [function () {
    return uni.request;
  }, function () {
    return wx.request;
  }, function () {
    return my.request;
  }, function () {
    return swan.request;
  }, function () {
    return tt.request;
  }, function () {
    return qq.request;
  }];
  var adapter;

  while (stack.length !== 0 && adapter === void 0) {
    try {
      adapter = stack.shift()();
    } catch (err) {}
  }

  return adapter;
}

var defaults = {
  /**
   * 适配器
   */
  adapter: adaptive(),

  /**
   * 请求方法
   */
  method: 'get',

  /**
   * 请求头
   */
  headers: {
    common: {
      Accept: 'application/json, test/plain, */*'
    },
    options: {},
    get: {},
    head: {},
    post: {
      'Context-Type': 'application/x-www-form-urlencoded; charset=utf-8'
    },
    put: {
      'Context-Type': 'application/x-www-form-urlencoded; charset=utf-8'
    },
    "delete": {},
    trace: {},
    connect: {}
  },

  /**
   * 状态码效验
   *
   * @param status 状态码
   */
  validateStatus: function validateStatus(status) {
    return status >= 200 && status < 300;
  },

  /**
   * 超时时间
   */
  timeout: 10000,

  /**
   * 响应数据格式
   */
  dataType: 'json',

  /**
   * 响应数据类型
   */
  responseType: 'text',

  /**
   * 开启 http2
   */
  enableHttp2: false,

  /**
   * 开启 quic
   */
  enableQuic: false,

  /**
   * 开启 cache
   */
  enableCache: false,

  /**
   * 验证 ssl 证书
   */
  sslVerify: true
};

/**
 * 创建一个新的 Axios 实例
 *
 * 返回一个 Axios 实例增强
 */

function createInstance(defaults) {
  var instance = new AxiosClass(defaults);
  /**
   * 支持重载的 axios 函数
   */

  function axios(url) {
    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    // 调用方式一处理请求配置
    if (typeof url !== 'string') {
      config = url;
    } // 调用方式二处理请求配置
    else {
        config = _objectSpread2(_objectSpread2({}, config), {}, {
          url: url
        });
      }

    return instance.request(config);
  } // instance 的属性合并到 axios 函数中


  Object.assign(axios, instance); // instance 的方法合并到 axios 函数中

  Object.setPrototypeOf(axios, Object.getPrototypeOf(instance));
  return axios;
}
/**
 * Axios 实例拓展
 */


var axios = createInstance(defaults); // 添加 create 工厂方法

axios.create = function create() {
  var defaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return createInstance(mergeConfig(axios.defaults, defaults));
}; // 添加 Axios 类


axios.Axios = AxiosClass; // 添加 CancelToken 类

axios.CancelToken = CancelTokenClass; // 添加 检查错误是否来自取消请求 方法

axios.isCancel = isCancel;

export default axios;