axios.js

女爷i 2023-06-18 07:53 3阅读 0赞

/\* axios v0.17.1 | (c) 2017 by Matt Zabriskie \*/  
(function webpackUniversalModuleDefinition(root, factory) \{  
    if(typeof exports === 'object' && typeof module === 'object')  
        module.exports = factory();  
    else if(typeof define === 'function' && define.amd)  
        define(\[\], factory);  
    else if(typeof exports === 'object')  
        exports\["axios"\] = factory();  
    else  
        root\["axios"\] = factory();  
\})(this, function() \{  
return /\*\*\*\*\*\*/ (function(modules) \{ // webpackBootstrap  
/\*\*\*\*\*\*/     // The module cache  
/\*\*\*\*\*\*/     var installedModules = \{\};  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/     // The require function  
/\*\*\*\*\*\*/     function \_\_webpack\_require\_\_(moduleId) \{  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/         // Check if module is in cache  
/\*\*\*\*\*\*/         if(installedModules\[moduleId\])  
/\*\*\*\*\*\*/             return installedModules\[moduleId\].exports;  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/         // Create a new module (and put it into the cache)  
/\*\*\*\*\*\*/         var module = installedModules\[moduleId\] = \{  
/\*\*\*\*\*\*/             exports: \{\},  
/\*\*\*\*\*\*/             id: moduleId,  
/\*\*\*\*\*\*/             loaded: false  
/\*\*\*\*\*\*/         \};  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/         // Execute the module function  
/\*\*\*\*\*\*/         modules\[moduleId\].call(module.exports, module, module.exports, \_\_webpack\_require\_\_);  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/         // Flag the module as loaded  
/\*\*\*\*\*\*/         module.loaded = true;  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/         // Return the exports of the module  
/\*\*\*\*\*\*/         return module.exports;  
/\*\*\*\*\*\*/     \}  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/     // expose the modules object (\_\_webpack\_modules\_\_)  
/\*\*\*\*\*\*/     \_\_webpack\_require\_\_.m = modules;  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/     // expose the module cache  
/\*\*\*\*\*\*/     \_\_webpack\_require\_\_.c = installedModules;  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/     // \_\_webpack\_public\_path\_\_  
/\*\*\*\*\*\*/     \_\_webpack\_require\_\_.p = "";  
/\*\*\*\*\*\*/  
/\*\*\*\*\*\*/     // Load entry module and return exports  
/\*\*\*\*\*\*/     return \_\_webpack\_require\_\_(0);  
/\*\*\*\*\*\*/ \})  
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
/\*\*\*\*\*\*/ (\[  
/\* 0 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

module.exports = \_\_webpack\_require\_\_(1);

/\*\*\*/ \}),  
/\* 1 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
    var bind = \_\_webpack\_require\_\_(3);  
    var Axios = \_\_webpack\_require\_\_(5);  
    var defaults = \_\_webpack\_require\_\_(6);  
      
    /\*\*  
     \* Create an instance of Axios  
     \*  
     \* @param \{Object\} defaultConfig The default config for the instance  
     \* @return \{Axios\} A new instance of Axios  
     \*/  
    function createInstance(defaultConfig) \{  
      var context = new Axios(defaultConfig);  
      var instance = bind(Axios.prototype.request, context);  
      
      // Copy axios.prototype to instance  
      utils.extend(instance, Axios.prototype, context);  
      
      // Copy context to instance  
      utils.extend(instance, context);  
      
      return instance;  
    \}  
      
    // Create the default instance to be exported  
    var axios = createInstance(defaults);  
      
    // Expose Axios class to allow class inheritance  
    axios.Axios = Axios;  
      
    // Factory for creating new instances  
    axios.create = function create(instanceConfig) \{  
      return createInstance(utils.merge(defaults, instanceConfig));  
    \};  
      
    // Expose Cancel & CancelToken  
    axios.Cancel = \_\_webpack\_require\_\_(23);  
    axios.CancelToken = \_\_webpack\_require\_\_(24);  
    axios.isCancel = \_\_webpack\_require\_\_(20);  
      
    // Expose all/spread  
    axios.all = function all(promises) \{  
      return Promise.all(promises);  
    \};  
    axios.spread = \_\_webpack\_require\_\_(25);  
      
    module.exports = axios;  
      
    // Allow use of default import syntax in TypeScript  
    module.exports.default = axios;

/\*\*\*/ \}),  
/\* 2 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var bind = \_\_webpack\_require\_\_(3);  
    var isBuffer = \_\_webpack\_require\_\_(4);  
      
    /\*global toString:true\*/  
      
    // utils is a library of generic helper functions non-specific to axios  
      
    var toString = Object.prototype.toString;  
      
    /\*\*  
     \* Determine if a value is an Array  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is an Array, otherwise false  
     \*/  
    function isArray(val) \{  
      return toString.call(val) === '\[object Array\]';  
    \}  
      
    /\*\*  
     \* Determine if a value is an ArrayBuffer  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is an ArrayBuffer, otherwise false  
     \*/  
    function isArrayBuffer(val) \{  
      return toString.call(val) === '\[object ArrayBuffer\]';  
    \}  
      
    /\*\*  
     \* Determine if a value is a FormData  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is an FormData, otherwise false  
     \*/  
    function isFormData(val) \{  
      return (typeof FormData !== 'undefined') && (val instanceof FormData);  
    \}  
      
    /\*\*  
     \* Determine if a value is a view on an ArrayBuffer  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a view on an ArrayBuffer, otherwise false  
     \*/  
    function isArrayBufferView(val) \{  
      var result;  
      if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) \{  
        result = ArrayBuffer.isView(val);  
      \} else \{  
        result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);  
      \}  
      return result;  
    \}  
      
    /\*\*  
     \* Determine if a value is a String  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a String, otherwise false  
     \*/  
    function isString(val) \{  
      return typeof val === 'string';  
    \}  
      
    /\*\*  
     \* Determine if a value is a Number  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a Number, otherwise false  
     \*/  
    function isNumber(val) \{  
      return typeof val === 'number';  
    \}  
      
    /\*\*  
     \* Determine if a value is undefined  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if the value is undefined, otherwise false  
     \*/  
    function isUndefined(val) \{  
      return typeof val === 'undefined';  
    \}  
      
    /\*\*  
     \* Determine if a value is an Object  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is an Object, otherwise false  
     \*/  
    function isObject(val) \{  
      return val !== null && typeof val === 'object';  
    \}  
      
    /\*\*  
     \* Determine if a value is a Date  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a Date, otherwise false  
     \*/  
    function isDate(val) \{  
      return toString.call(val) === '\[object Date\]';  
    \}  
      
    /\*\*  
     \* Determine if a value is a File  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a File, otherwise false  
     \*/  
    function isFile(val) \{  
      return toString.call(val) === '\[object File\]';  
    \}  
      
    /\*\*  
     \* Determine if a value is a Blob  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a Blob, otherwise false  
     \*/  
    function isBlob(val) \{  
      return toString.call(val) === '\[object Blob\]';  
    \}  
      
    /\*\*  
     \* Determine if a value is a Function  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a Function, otherwise false  
     \*/  
    function isFunction(val) \{  
      return toString.call(val) === '\[object Function\]';  
    \}  
      
    /\*\*  
     \* Determine if a value is a Stream  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a Stream, otherwise false  
     \*/  
    function isStream(val) \{  
      return isObject(val) && isFunction(val.pipe);  
    \}  
      
    /\*\*  
     \* Determine if a value is a URLSearchParams object  
     \*  
     \* @param \{Object\} val The value to test  
     \* @returns \{boolean\} True if value is a URLSearchParams object, otherwise false  
     \*/  
    function isURLSearchParams(val) \{  
      return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;  
    \}  
      
    /\*\*  
     \* Trim excess whitespace off the beginning and end of a string  
     \*  
     \* @param \{String\} str The String to trim  
     \* @returns \{String\} The String freed of excess whitespace  
     \*/  
    function trim(str) \{  
      return str.replace(/^\\s\*/, '').replace(/\\s\*$/, '');  
    \}  
      
    /\*\*  
     \* Determine if we're running in a standard browser environment  
     \*  
     \* This allows axios to run in a web worker, and react-native.  
     \* Both environments support XMLHttpRequest, but not fully standard globals.  
     \*  
     \* web workers:  
     \*  typeof window -> undefined  
     \*  typeof document -> undefined  
     \*  
     \* react-native:  
     \*  navigator.product -> 'ReactNative'  
     \*/  
    function isStandardBrowserEnv() \{  
      if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') \{  
        return false;  
      \}  
      return (  
        typeof window !== 'undefined' &&  
        typeof document !== 'undefined'  
      );  
    \}  
      
    /\*\*  
     \* Iterate over an Array or an Object invoking a function for each item.  
     \*  
     \* If \`obj\` is an Array callback will be called passing  
     \* the value, index, and complete array for each item.  
     \*  
     \* If 'obj' is an Object callback will be called passing  
     \* the value, key, and complete object for each property.  
     \*  
     \* @param \{Object|Array\} obj The object to iterate  
     \* @param \{Function\} fn The callback to invoke for each item  
     \*/  
    function forEach(obj, fn) \{  
      // Don't bother if no value provided  
      if (obj === null || typeof obj === 'undefined') \{  
        return;  
      \}  
      
      // Force an array if not already something iterable  
      if (typeof obj !== 'object') \{  
        /\*eslint no-param-reassign:0\*/  
        obj = \[obj\];  
      \}  
      
      if (isArray(obj)) \{  
        // Iterate over array values  
        for (var i = 0, l = obj.length; i < l; i++) \{  
          fn.call(null, obj\[i\], i, obj);  
        \}  
      \} else \{  
        // Iterate over object keys  
        for (var key in obj) \{  
          if (Object.prototype.hasOwnProperty.call(obj, key)) \{  
            fn.call(null, obj\[key\], key, obj);  
          \}  
        \}  
      \}  
    \}  
      
    /\*\*  
     \* Accepts varargs expecting each argument to be an object, then  
     \* immutably merges the properties of each object and returns result.  
     \*  
     \* When multiple objects contain the same key the later object in  
     \* the arguments list will take precedence.  
     \*  
     \* Example:  
     \*  
     \* \`\`\`js  
     \* var result = merge(\{foo: 123\}, \{foo: 456\});  
     \* console.log(result.foo); // outputs 456  
     \* \`\`\`  
     \*  
     \* @param \{Object\} obj1 Object to merge  
     \* @returns \{Object\} Result of all merge properties  
     \*/  
    function merge(/\* obj1, obj2, obj3, ... \*/) \{  
      var result = \{\};  
      function assignValue(val, key) \{  
        if (typeof result\[key\] === 'object' && typeof val === 'object') \{  
          result\[key\] = merge(result\[key\], val);  
        \} else \{  
          result\[key\] = val;  
        \}  
      \}  
      
      for (var i = 0, l = arguments.length; i < l; i++) \{  
        forEach(arguments\[i\], assignValue);  
      \}  
      return result;  
    \}  
      
    /\*\*  
     \* Extends object a by mutably adding to it the properties of object b.  
     \*  
     \* @param \{Object\} a The object to be extended  
     \* @param \{Object\} b The object to copy properties from  
     \* @param \{Object\} thisArg The object to bind function to  
     \* @return \{Object\} The resulting value of object a  
     \*/  
    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;  
    \}  
      
    module.exports = \{  
      isArray: isArray,  
      isArrayBuffer: isArrayBuffer,  
      isBuffer: isBuffer,  
      isFormData: isFormData,  
      isArrayBufferView: isArrayBufferView,  
      isString: isString,  
      isNumber: isNumber,  
      isObject: isObject,  
      isUndefined: isUndefined,  
      isDate: isDate,  
      isFile: isFile,  
      isBlob: isBlob,  
      isFunction: isFunction,  
      isStream: isStream,  
      isURLSearchParams: isURLSearchParams,  
      isStandardBrowserEnv: isStandardBrowserEnv,  
      forEach: forEach,  
      merge: merge,  
      extend: extend,  
      trim: trim  
    \};

/\*\*\*/ \}),  
/\* 3 \*/  
/\*\*\*/ (function(module, exports) \{

'use strict';  
      
    module.exports = 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);  
      \};  
    \};

/\*\*\*/ \}),  
/\* 4 \*/  
/\*\*\*/ (function(module, exports) \{

/\*!  
     \* Determine if an object is a Buffer  
     \*  
     \* @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>  
     \* @license  MIT  
     \*/  
      
    // The \_isBuffer check is for Safari 5-7 support, because it's missing  
    // Object.prototype.constructor. Remove this eventually  
    module.exports = function (obj) \{  
      return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj.\_isBuffer)  
    \}  
      
    function isBuffer (obj) \{  
      return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)  
    \}  
      
    // For Node v0.10 support. Remove this eventually.  
    function isSlowBuffer (obj) \{  
      return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))  
    \}

/\*\*\*/ \}),  
/\* 5 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var defaults = \_\_webpack\_require\_\_(6);  
    var utils = \_\_webpack\_require\_\_(2);  
    var InterceptorManager = \_\_webpack\_require\_\_(17);  
    var dispatchRequest = \_\_webpack\_require\_\_(18);  
      
    /\*\*  
     \* Create a new instance of Axios  
     \*  
     \* @param \{Object\} instanceConfig The default config for the instance  
     \*/  
    function Axios(instanceConfig) \{  
      this.defaults = instanceConfig;  
      this.interceptors = \{  
        request: new InterceptorManager(),  
        response: new InterceptorManager()  
      \};  
    \}  
      
    /\*\*  
     \* Dispatch a request  
     \*  
     \* @param \{Object\} config The config specific for this request (merged with this.defaults)  
     \*/  
    Axios.prototype.request = function request(config) \{  
      /\*eslint no-param-reassign:0\*/  
      // Allow for axios('example/url'\[, config\]) a la fetch API  
      if (typeof config === 'string') \{  
        config = utils.merge(\{  
          url: arguments\[0\]  
        \}, arguments\[1\]);  
      \}  
      
      config = utils.merge(defaults, this.defaults, \{ method: 'get' \}, config);  
      config.method = config.method.toLowerCase();  
      
      // Hook up interceptors middleware  
      var chain = \[dispatchRequest, undefined\];  
      var promise = Promise.resolve(config);  
      
      this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) \{  
        chain.unshift(interceptor.fulfilled, interceptor.rejected);  
      \});  
      
      this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) \{  
        chain.push(interceptor.fulfilled, interceptor.rejected);  
      \});  
      
      while (chain.length) \{  
        promise = promise.then(chain.shift(), chain.shift());  
      \}  
      
      return promise;  
    \};  
      
    // Provide aliases for supported request methods  
    utils.forEach(\['delete', 'get', 'head', 'options'\], function forEachMethodNoData(method) \{  
      /\*eslint func-names:0\*/  
      Axios.prototype\[method\] = function(url, config) \{  
        return this.request(utils.merge(config || \{\}, \{  
          method: method,  
          url: url  
        \}));  
      \};  
    \});  
      
    utils.forEach(\['post', 'put', 'patch'\], function forEachMethodWithData(method) \{  
      /\*eslint func-names:0\*/  
      Axios.prototype\[method\] = function(url, data, config) \{  
        return this.request(utils.merge(config || \{\}, \{  
          method: method,  
          url: url,  
          data: data  
        \}));  
      \};  
    \});  
      
    module.exports = Axios;

/\*\*\*/ \}),  
/\* 6 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
    var normalizeHeaderName = \_\_webpack\_require\_\_(7);  
      
    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') \{  
        // For browsers use XHR adapter  
        adapter = \_\_webpack\_require\_\_(8);  
      \} else if (typeof process !== 'undefined') \{  
        // For node use HTTP adapter  
        adapter = \_\_webpack\_require\_\_(8);  
      \}  
      return adapter;  
    \}  
      
    var defaults = \{  
      adapter: getDefaultAdapter(),  
      
      transformRequest: \[function transformRequest(data, headers) \{  
        normalizeHeaderName(headers, 'Content-Type');  
        if (utils.isFormData(data) ||  
          utils.isArrayBuffer(data) ||  
          utils.isBuffer(data) ||  
          utils.isStream(data) ||  
          utils.isFile(data) ||  
          utils.isBlob(data)  
        ) \{  
          return data;  
        \}  
        if (utils.isArrayBufferView(data)) \{  
          return data.buffer;  
        \}  
        if (utils.isURLSearchParams(data)) \{  
          setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');  
          return data.toString();  
        \}  
        if (utils.isObject(data)) \{  
          setContentTypeIfUnset(headers, 'application/json;charset=utf-8');  
          return JSON.stringify(data);  
        \}  
        return data;  
      \}\],  
      
      transformResponse: \[function transformResponse(data) \{  
        /\*eslint no-param-reassign:0\*/  
        if (typeof data === 'string') \{  
          try \{  
            data = JSON.parse(data);  
          \} catch (e) \{ /\* Ignore \*/ \}  
        \}  
        return data;  
      \}\],  
      
      timeout: 0,  
      
      xsrfCookieName: 'XSRF-TOKEN',  
      xsrfHeaderName: 'X-XSRF-TOKEN',  
      
      maxContentLength: -1,  
      
      validateStatus: function validateStatus(status) \{  
        return status >= 200 && status < 300;  
      \}  
    \};  
      
    defaults.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);  
    \});  
      
    module.exports = defaults;

/\*\*\*/ \}),  
/\* 7 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
      
    module.exports = function normalizeHeaderName(headers, normalizedName) \{  
      utils.forEach(headers, function processHeader(value, name) \{  
        if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) \{  
          headers\[normalizedName\] = value;  
          delete headers\[name\];  
        \}  
      \});  
    \};

/\*\*\*/ \}),  
/\* 8 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
    var settle = \_\_webpack\_require\_\_(9);  
    var buildURL = \_\_webpack\_require\_\_(12);  
    var parseHeaders = \_\_webpack\_require\_\_(13);  
    var isURLSameOrigin = \_\_webpack\_require\_\_(14);  
    var createError = \_\_webpack\_require\_\_(10);  
    var btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || \_\_webpack\_require\_\_(15);  
      
    module.exports = function xhrAdapter(config) \{  
      return new Promise(function dispatchXhrRequest(resolve, reject) \{  
        var requestData = config.data;  
        var requestHeaders = config.headers;  
      
        if (utils.isFormData(requestData)) \{  
          delete requestHeaders\['Content-Type'\]; // Let the browser set it  
        \}  
      
        var request = new XMLHttpRequest();  
        var loadEvent = 'onreadystatechange';  
        var xDomain = false;  
      
        // For IE 8/9 CORS support  
        // Only supports POST and GET calls and doesn't returns the response headers.  
        // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.  
        if (("production") !== 'test' &&  
            typeof window !== 'undefined' &&  
            window.XDomainRequest && !('withCredentials' in request) &&  
            !isURLSameOrigin(config.url)) \{  
          request = new window.XDomainRequest();  
          loadEvent = 'onload';  
          xDomain = true;  
          request.onprogress = function handleProgress() \{\};  
          request.ontimeout = function handleTimeout() \{\};  
        \}  
      
        // HTTP basic authentication  
        if (config.auth) \{  
          var username = config.auth.username || '';  
          var password = config.auth.password || '';  
          requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);  
        \}  
      
        request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);  
      
        // Set the request timeout in MS  
        request.timeout = config.timeout;  
      
        // Listen for ready state  
        request\[loadEvent\] = function handleLoad() \{  
          if (!request || (request.readyState !== 4 && !xDomain)) \{  
            return;  
          \}  
      
          // The request errored out and we didn't get a response, this will be  
          // handled by onerror instead  
          // With one exception: request that using file: protocol, most browsers  
          // will return status as 0 even though it's a successful request  
          if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) \{  
            return;  
          \}  
      
          // Prepare the response  
          var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;  
          var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;  
          var response = \{  
            data: responseData,  
            // IE sends 1223 instead of 204 (https://github.com/axios/axios/issues/201)  
            status: request.status === 1223 ? 204 : request.status,  
            statusText: request.status === 1223 ? 'No Content' : request.statusText,  
            headers: responseHeaders,  
            config: config,  
            request: request  
          \};  
      
          settle(resolve, reject, response);  
      
          // Clean up request  
          request = null;  
        \};  
      
        // Handle low level network errors  
        request.onerror = function handleError() \{  
          // Real errors are hidden from us by the browser  
          // onerror should only fire if it's a network error  
          reject(createError('Network Error', config, null, request));  
      
          // Clean up request  
          request = null;  
        \};  
      
        // Handle timeout  
        request.ontimeout = function handleTimeout() \{  
          reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED',  
            request));  
      
          // Clean up request  
          request = null;  
        \};  
      
        // Add xsrf header  
        // This is only done if running in a standard browser environment.  
        // Specifically not if we're in a web worker, or react-native.  
        if (utils.isStandardBrowserEnv()) \{  
          var cookies = \_\_webpack\_require\_\_(16);  
      
          // Add xsrf header  
          var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?  
              cookies.read(config.xsrfCookieName) :  
              undefined;  
      
          if (xsrfValue) \{  
            requestHeaders\[config.xsrfHeaderName\] = xsrfValue;  
          \}  
        \}  
      
        // Add headers to the request  
        if ('setRequestHeader' in request) \{  
          utils.forEach(requestHeaders, function setRequestHeader(val, key) \{  
            if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') \{  
              // Remove Content-Type if data is undefined  
              delete requestHeaders\[key\];  
            \} else \{  
              // Otherwise add header to the request  
              request.setRequestHeader(key, val);  
            \}  
          \});  
        \}  
      
        // Add withCredentials to request if needed  
        if (config.withCredentials) \{  
          request.withCredentials = true;  
        \}  
      
        // Add responseType to request if needed  
        if (config.responseType) \{  
          try \{  
            request.responseType = config.responseType;  
          \} catch (e) \{  
            // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.  
            // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.  
            if (config.responseType !== 'json') \{  
              throw e;  
            \}  
          \}  
        \}  
      
        // Handle progress if needed  
        if (typeof config.onDownloadProgress === 'function') \{  
          request.addEventListener('progress', config.onDownloadProgress);  
        \}  
      
        // Not all browsers support upload events  
        if (typeof config.onUploadProgress === 'function' && request.upload) \{  
          request.upload.addEventListener('progress', config.onUploadProgress);  
        \}  
      
        if (config.cancelToken) \{  
          // Handle cancellation  
          config.cancelToken.promise.then(function onCanceled(cancel) \{  
            if (!request) \{  
              return;  
            \}  
      
            request.abort();  
            reject(cancel);  
            // Clean up request  
            request = null;  
          \});  
        \}  
      
        if (requestData === undefined) \{  
          requestData = null;  
        \}  
      
        // Send the request  
        request.send(requestData);  
      \});  
    \};

/\*\*\*/ \}),  
/\* 9 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var createError = \_\_webpack\_require\_\_(10);  
      
    /\*\*  
     \* Resolve or reject a Promise based on response status.  
     \*  
     \* @param \{Function\} resolve A function that resolves the promise.  
     \* @param \{Function\} reject A function that rejects the promise.  
     \* @param \{object\} response The response.  
     \*/  
    module.exports = function settle(resolve, reject, response) \{  
      var validateStatus = response.config.validateStatus;  
      // Note: status is not exposed by XDomainRequest  
      if (!response.status || !validateStatus || validateStatus(response.status)) \{  
        resolve(response);  
      \} else \{  
        reject(createError(  
          'Request failed with status code ' + response.status,  
          response.config,  
          null,  
          response.request,  
          response  
        ));  
      \}  
    \};

/\*\*\*/ \}),  
/\* 10 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var enhanceError = \_\_webpack\_require\_\_(11);  
      
    /\*\*  
     \* Create an Error with the specified message, config, error code, request and response.  
     \*  
     \* @param \{string\} message The error message.  
     \* @param \{Object\} config The config.  
     \* @param \{string\} \[code\] The error code (for example, 'ECONNABORTED').  
     \* @param \{Object\} \[request\] The request.  
     \* @param \{Object\} \[response\] The response.  
     \* @returns \{Error\} The created error.  
     \*/  
    module.exports = function createError(message, config, code, request, response) \{  
      var error = new Error(message);  
      return enhanceError(error, config, code, request, response);  
    \};

/\*\*\*/ \}),  
/\* 11 \*/  
/\*\*\*/ (function(module, exports) \{

'use strict';  
      
    /\*\*  
     \* Update an Error with the specified config, error code, and response.  
     \*  
     \* @param \{Error\} error The error to update.  
     \* @param \{Object\} config The config.  
     \* @param \{string\} \[code\] The error code (for example, 'ECONNABORTED').  
     \* @param \{Object\} \[request\] The request.  
     \* @param \{Object\} \[response\] The response.  
     \* @returns \{Error\} The error.  
     \*/  
    module.exports = function enhanceError(error, config, code, request, response) \{  
      error.config = config;  
      if (code) \{  
        error.code = code;  
      \}  
      error.request = request;  
      error.response = response;  
      return error;  
    \};

/\*\*\*/ \}),  
/\* 12 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
      
    function encode(val) \{  
      return encodeURIComponent(val).  
        replace(/%40/gi, '@').  
        replace(/%3A/gi, ':').  
        replace(/%24/g, '$').  
        replace(/%2C/gi, ',').  
        replace(/%20/g, '+').  
        replace(/%5B/gi, '\[').  
        replace(/%5D/gi, '\]');  
    \}  
      
    /\*\*  
     \* Build a URL by appending params to the end  
     \*  
     \* @param \{string\} url The base of the url (e.g., http://www.google.com)  
     \* @param \{object\} \[params\] The params to be appended  
     \* @returns \{string\} The formatted url  
     \*/  
    module.exports = function buildURL(url, params, paramsSerializer) \{  
      /\*eslint no-param-reassign:0\*/  
      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 + '\[\]';  
          \}  
      
          if (!utils.isArray(val)) \{  
            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) \{  
        url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;  
      \}  
      
      return url;  
    \};

/\*\*\*/ \}),  
/\* 13 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
      
    // Headers whose duplicates are ignored by node  
    // c.f. https://nodejs.org/api/http.html\#http\_message\_headers  
    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'  
    \];  
      
    /\*\*  
     \* Parse headers into an object  
     \*  
     \* \`\`\`  
     \* Date: Wed, 27 Aug 2014 08:58:49 GMT  
     \* Content-Type: application/json  
     \* Connection: keep-alive  
     \* Transfer-Encoding: chunked  
     \* \`\`\`  
     \*  
     \* @param \{String\} headers Headers needing to be parsed  
     \* @returns \{Object\} Headers parsed into an object  
     \*/  
    module.exports = function parseHeaders(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;  
    \};

/\*\*\*/ \}),  
/\* 14 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
      
    module.exports = (  
      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 standardBrowserEnv() \{  
        var msie = /(msie|trident)/i.test(navigator.userAgent);  
        var urlParsingNode = document.createElement('a');  
        var originURL;  
      
        /\*\*  
        \* Parse a URL to discover it's components  
        \*  
        \* @param \{String\} url The URL to be parsed  
        \* @returns \{Object\}  
        \*/  
        function resolveURL(url) \{  
          var href = url;  
      
          if (msie) \{  
            // IE needs attribute set twice to normalize properties  
            urlParsingNode.setAttribute('href', href);  
            href = urlParsingNode.href;  
          \}  
      
          urlParsingNode.setAttribute('href', href);  
      
          // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/\#urlutils  
          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);  
      
        /\*\*  
        \* Determine if a URL shares the same origin as the current location  
        \*  
        \* @param \{String\} requestURL The URL to test  
        \* @returns \{boolean\} True if URL shares the same origin, otherwise false  
        \*/  
        return function isURLSameOrigin(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 nonStandardBrowserEnv() \{  
        return function isURLSameOrigin() \{  
          return true;  
        \};  
      \})()  
    );

/\*\*\*/ \}),  
/\* 15 \*/  
/\*\*\*/ (function(module, exports) \{

'use strict';  
      
    // btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js  
      
    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';  
      
    function E() \{  
      this.message = 'String contains an invalid character';  
    \}  
    E.prototype = new Error;  
    E.prototype.code = 5;  
    E.prototype.name = 'InvalidCharacterError';  
      
    function btoa(input) \{  
      var str = String(input);  
      var output = '';  
      for (  
        // initialize result and counter  
        var block, charCode, idx = 0, map = chars;  
        // if the next str index does not exist:  
        //   change the mapping table to "="  
        //   check if d has no fractional digits  
        str.charAt(idx | 0) || (map = '=', idx % 1);  
        // "8 - idx % 1 \* 8" generates the sequence 2, 4, 6, 8  
        output += map.charAt(63 & block >> 8 - idx % 1 \* 8)  
      ) \{  
        charCode = str.charCodeAt(idx += 3 / 4);  
        if (charCode > 0xFF) \{  
          throw new E();  
        \}  
        block = block << 8 | charCode;  
      \}  
      return output;  
    \}  
      
    module.exports = btoa;

/\*\*\*/ \}),  
/\* 16 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
      
    module.exports = (  
      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() - 86400000);  
          \}  
        \};  
      \})() :  
      
      // 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() \{\}  
        \};  
      \})()  
    );

/\*\*\*/ \}),  
/\* 17 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
      
    function InterceptorManager() \{  
      this.handlers = \[\];  
    \}  
      
    /\*\*  
     \* Add a new interceptor to the stack  
     \*  
     \* @param \{Function\} fulfilled The function to handle \`then\` for a \`Promise\`  
     \* @param \{Function\} rejected The function to handle \`reject\` for a \`Promise\`  
     \*  
     \* @return \{Number\} An ID used to remove interceptor later  
     \*/  
    InterceptorManager.prototype.use = function use(fulfilled, rejected) \{  
      this.handlers.push(\{  
        fulfilled: fulfilled,  
        rejected: rejected  
      \});  
      return this.handlers.length - 1;  
    \};  
      
    /\*\*  
     \* Remove an interceptor from the stack  
     \*  
     \* @param \{Number\} id The ID that was returned by \`use\`  
     \*/  
    InterceptorManager.prototype.eject = function eject(id) \{  
      if (this.handlers\[id\]) \{  
        this.handlers\[id\] = null;  
      \}  
    \};  
      
    /\*\*  
     \* Iterate over all the registered interceptors  
     \*  
     \* This method is particularly useful for skipping over any  
     \* interceptors that may have become \`null\` calling \`eject\`.  
     \*  
     \* @param \{Function\} fn The function to call for each interceptor  
     \*/  
    InterceptorManager.prototype.forEach = function forEach(fn) \{  
      utils.forEach(this.handlers, function forEachHandler(h) \{  
        if (h !== null) \{  
          fn(h);  
        \}  
      \});  
    \};  
      
    module.exports = InterceptorManager;

/\*\*\*/ \}),  
/\* 18 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
    var transformData = \_\_webpack\_require\_\_(19);  
    var isCancel = \_\_webpack\_require\_\_(20);  
    var defaults = \_\_webpack\_require\_\_(6);  
    var isAbsoluteURL = \_\_webpack\_require\_\_(21);  
    var combineURLs = \_\_webpack\_require\_\_(22);  
      
    /\*\*  
     \* Throws a \`Cancel\` if cancellation has been requested.  
     \*/  
    function throwIfCancellationRequested(config) \{  
      if (config.cancelToken) \{  
        config.cancelToken.throwIfRequested();  
      \}  
    \}  
      
    /\*\*  
     \* Dispatch a request to the server using the configured adapter.  
     \*  
     \* @param \{object\} config The config that is to be used for the request  
     \* @returns \{Promise\} The Promise to be fulfilled  
     \*/  
    module.exports = function dispatchRequest(config) \{  
      throwIfCancellationRequested(config);  
      
      // Support baseURL config  
      if (config.baseURL && !isAbsoluteURL(config.url)) \{  
        config.url = combineURLs(config.baseURL, config.url);  
      \}  
      
      // Ensure headers exist  
      config.headers = config.headers || \{\};  
      
      // Transform request data  
      config.data = transformData(  
        config.data,  
        config.headers,  
        config.transformRequest  
      );  
      
      // Flatten headers  
      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.adapter;  
      
      return adapter(config).then(function onAdapterResolution(response) \{  
        throwIfCancellationRequested(config);  
      
        // Transform response data  
        response.data = transformData(  
          response.data,  
          response.headers,  
          config.transformResponse  
        );  
      
        return response;  
      \}, function onAdapterRejection(reason) \{  
        if (!isCancel(reason)) \{  
          throwIfCancellationRequested(config);  
      
          // Transform response data  
          if (reason && reason.response) \{  
            reason.response.data = transformData(  
              reason.response.data,  
              reason.response.headers,  
              config.transformResponse  
            );  
          \}  
        \}  
      
        return Promise.reject(reason);  
      \});  
    \};

/\*\*\*/ \}),  
/\* 19 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var utils = \_\_webpack\_require\_\_(2);  
      
    /\*\*  
     \* Transform the data for a request or a response  
     \*  
     \* @param \{Object|String\} data The data to be transformed  
     \* @param \{Array\} headers The headers for the request or response  
     \* @param \{Array|Function\} fns A single function or Array of functions  
     \* @returns \{\*\} The resulting transformed data  
     \*/  
    module.exports = function transformData(data, headers, fns) \{  
      /\*eslint no-param-reassign:0\*/  
      utils.forEach(fns, function transform(fn) \{  
        data = fn(data, headers);  
      \});  
      
      return data;  
    \};

/\*\*\*/ \}),  
/\* 20 \*/  
/\*\*\*/ (function(module, exports) \{

'use strict';  
      
    module.exports = function isCancel(value) \{  
      return !!(value && value.\_\_CANCEL\_\_);  
    \};

/\*\*\*/ \}),  
/\* 21 \*/  
/\*\*\*/ (function(module, exports) \{

'use strict';  
      
    /\*\*  
     \* Determines whether the specified URL is absolute  
     \*  
     \* @param \{string\} url The URL to test  
     \* @returns \{boolean\} True if the specified URL is absolute, otherwise false  
     \*/  
    module.exports = function isAbsoluteURL(url) \{  
      // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).  
      // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed  
      // by any combination of letters, digits, plus, period, or hyphen.  
      return /^(\[a-z\]\[a-z\\d\\+\\-\\.\]\*:)?\\/\\//i.test(url);  
    \};

/\*\*\*/ \}),  
/\* 22 \*/  
/\*\*\*/ (function(module, exports) \{

'use strict';  
      
    /\*\*  
     \* Creates a new URL by combining the specified URLs  
     \*  
     \* @param \{string\} baseURL The base URL  
     \* @param \{string\} relativeURL The relative URL  
     \* @returns \{string\} The combined URL  
     \*/  
    module.exports = function combineURLs(baseURL, relativeURL) \{  
      return relativeURL  
        ? baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '')  
        : baseURL;  
    \};

/\*\*\*/ \}),  
/\* 23 \*/  
/\*\*\*/ (function(module, exports) \{

'use strict';  
      
    /\*\*  
     \* A \`Cancel\` is an object that is thrown when an operation is canceled.  
     \*  
     \* @class  
     \* @param \{string=\} message The message.  
     \*/  
    function Cancel(message) \{  
      this.message = message;  
    \}  
      
    Cancel.prototype.toString = function toString() \{  
      return 'Cancel' + (this.message ? ': ' + this.message : '');  
    \};  
      
    Cancel.prototype.\_\_CANCEL\_\_ = true;  
      
    module.exports = Cancel;

/\*\*\*/ \}),  
/\* 24 \*/  
/\*\*\*/ (function(module, exports, \_\_webpack\_require\_\_) \{

'use strict';  
      
    var Cancel = \_\_webpack\_require\_\_(23);  
      
    /\*\*  
     \* A \`CancelToken\` is an object that can be used to request cancellation of an operation.  
     \*  
     \* @class  
     \* @param \{Function\} executor The executor function.  
     \*/  
    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;  
      executor(function cancel(message) \{  
        if (token.reason) \{  
          // Cancellation has already been requested  
          return;  
        \}  
      
        token.reason = new Cancel(message);  
        resolvePromise(token.reason);  
      \});  
    \}  
      
    /\*\*  
     \* Throws a \`Cancel\` if cancellation has been requested.  
     \*/  
    CancelToken.prototype.throwIfRequested = function throwIfRequested() \{  
      if (this.reason) \{  
        throw this.reason;  
      \}  
    \};  
      
    /\*\*  
     \* Returns an object that contains a new \`CancelToken\` and a function that, when called,  
     \* cancels the \`CancelToken\`.  
     \*/  
    CancelToken.source = function source() \{  
      var cancel;  
      var token = new CancelToken(function executor(c) \{  
        cancel = c;  
      \});  
      return \{  
        token: token,  
        cancel: cancel  
      \};  
    \};  
      
    module.exports = CancelToken;

/\*\*\*/ \}),  
/\* 25 \*/  
/\*\*\*/ (function(module, exports) \{

'use strict';  
      
    /\*\*  
     \* Syntactic sugar for invoking a function and expanding an array for arguments.  
     \*  
     \* Common use case would be to use \`Function.prototype.apply\`.  
     \*  
     \*  \`\`\`js  
     \*  function f(x, y, z) \{\}  
     \*  var args = \[1, 2, 3\];  
     \*  f.apply(null, args);  
     \*  \`\`\`  
     \*  
     \* With \`spread\` this example can be re-written.  
     \*  
     \*  \`\`\`js  
     \*  spread(function(x, y, z) \{\})(\[1, 2, 3\]);  
     \*  \`\`\`  
     \*  
     \* @param \{Function\} callback  
     \* @returns \{Function\}  
     \*/  
    module.exports = function spread(callback) \{  
      return function wrap(arr) \{  
        return callback.apply(null, arr);  
      \};  
    \};

/\*\*\*/ \})  
/\*\*\*\*\*\*/ \])  
\});  
;  
//\# sourceMappingURL=axios.map

axios.js

发表评论取消回复

还没有评论，来说两句吧...

相关阅读