@neurosity/sdk 7.0.1 → 7.2.0

package/dist/neurosity.umd.js

@@ -142,7 +142,7 @@
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
-    function isFunction$2(value) {
+    function isFunction$3(value) {
         return typeof value === 'function';
     }
 
@@ -210,7 +210,7 @@
                     }
                 }
                 var initialFinalizer = this.initialTeardown;
-                if (isFunction$2(initialFinalizer)) {
+                if (isFunction$3(initialFinalizer)) {
                     try {
                         initialFinalizer();
                     }
@@ -302,10 +302,10 @@
     var EMPTY_SUBSCRIPTION = Subscription$1.EMPTY;
     function isSubscription(value) {
         return (value instanceof Subscription$1 ||
-            (value && 'closed' in value && isFunction$2(value.remove) && isFunction$2(value.add) && isFunction$2(value.unsubscribe)));
+            (value && 'closed' in value && isFunction$3(value.remove) && isFunction$3(value.add) && isFunction$3(value.unsubscribe)));
     }
     function execFinalizer(finalizer) {
-        if (isFunction$2(finalizer)) {
+        if (isFunction$3(finalizer)) {
             finalizer();
         }
         else {
@@ -460,7 +460,7 @@
         function SafeSubscriber(observerOrNext, error, complete) {
             var _this = _super.call(this) || this;
             var partialObserver;
-            if (isFunction$2(observerOrNext) || !observerOrNext) {
+            if (isFunction$3(observerOrNext) || !observerOrNext) {
                 partialObserver = {
                     next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),
                     error: error !== null && error !== void 0 ? error : undefined,
@@ -605,14 +605,14 @@
         return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config$1.Promise) !== null && _a !== void 0 ? _a : Promise;
     }
     function isObserver(value) {
-        return value && isFunction$2(value.next) && isFunction$2(value.error) && isFunction$2(value.complete);
+        return value && isFunction$3(value.next) && isFunction$3(value.error) && isFunction$3(value.complete);
     }
     function isSubscriber(value) {
         return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
     }
 
     function hasLift(source) {
-        return isFunction$2(source === null || source === void 0 ? void 0 : source.lift);
+        return isFunction$3(source === null || source === void 0 ? void 0 : source.lift);
     }
     function operate(init) {
         return function (source) {
@@ -1107,14 +1107,14 @@
     var EMPTY = new Observable(function (subscriber) { return subscriber.complete(); });
 
     function isScheduler(value) {
-        return value && isFunction$2(value.schedule);
+        return value && isFunction$3(value.schedule);
     }
 
     function last(arr) {
         return arr[arr.length - 1];
     }
     function popResultSelector(args) {
-        return isFunction$2(last(args)) ? args.pop() : undefined;
+        return isFunction$3(last(args)) ? args.pop() : undefined;
     }
     function popScheduler(args) {
         return isScheduler(last(args)) ? args.pop() : undefined;
@@ -1126,15 +1126,15 @@
     var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
 
     function isPromise(value) {
-        return isFunction$2(value === null || value === void 0 ? void 0 : value.then);
+        return isFunction$3(value === null || value === void 0 ? void 0 : value.then);
     }
 
     function isInteropObservable(input) {
-        return isFunction$2(input[observable]);
+        return isFunction$3(input[observable]);
     }
 
     function isAsyncIterable(obj) {
-        return Symbol.asyncIterator && isFunction$2(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+        return Symbol.asyncIterator && isFunction$3(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
     }
 
     function createInvalidObservableTypeError(input) {
@@ -1147,10 +1147,10 @@
         }
         return Symbol.iterator;
     }
-    var iterator = getSymbolIterator();
+    var iterator$1 = getSymbolIterator();
 
-    function isIterable(input) {
-        return isFunction$2(input === null || input === void 0 ? void 0 : input[iterator]);
+    function isIterable$1(input) {
+        return isFunction$3(input === null || input === void 0 ? void 0 : input[iterator$1]);
     }
 
     function readableStreamLikeToAsyncGenerator(readableStream) {
@@ -1186,7 +1186,7 @@
         });
     }
     function isReadableStreamLike(obj) {
-        return isFunction$2(obj === null || obj === void 0 ? void 0 : obj.getReader);
+        return isFunction$3(obj === null || obj === void 0 ? void 0 : obj.getReader);
     }
 
     function innerFrom(input) {
@@ -1206,7 +1206,7 @@
             if (isAsyncIterable(input)) {
                 return fromAsyncIterable(input);
             }
-            if (isIterable(input)) {
+            if (isIterable$1(input)) {
                 return fromIterable(input);
             }
             if (isReadableStreamLike(input)) {
@@ -1218,7 +1218,7 @@
     function fromInteropObservable(obj) {
         return new Observable(function (subscriber) {
             var obs = obj[observable]();
-            if (isFunction$2(obs.subscribe)) {
+            if (isFunction$3(obs.subscribe)) {
                 return obs.subscribe(subscriber);
             }
             throw new TypeError('Provided object does not correctly implement Symbol.observable');
@@ -1379,15 +1379,15 @@
 
     function scheduleIterable(input, scheduler) {
         return new Observable(function (subscriber) {
-            var iterator$1;
+            var iterator;
             executeSchedule(subscriber, scheduler, function () {
-                iterator$1 = input[iterator]();
+                iterator = input[iterator$1]();
                 executeSchedule(subscriber, scheduler, function () {
                     var _a;
                     var value;
                     var done;
                     try {
-                        (_a = iterator$1.next(), value = _a.value, done = _a.done);
+                        (_a = iterator.next(), value = _a.value, done = _a.done);
                     }
                     catch (err) {
                         subscriber.error(err);
@@ -1401,7 +1401,7 @@
                     }
                 }, 0, true);
             });
-            return function () { return isFunction$2(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return(); };
+            return function () { return isFunction$3(iterator === null || iterator === void 0 ? void 0 : iterator.return) && iterator.return(); };
         });
     }
 
@@ -1444,7 +1444,7 @@
             if (isAsyncIterable(input)) {
                 return scheduleAsyncIterable(input, scheduler);
             }
-            if (isIterable(input)) {
+            if (isIterable$1(input)) {
                 return scheduleIterable(input, scheduler);
             }
             if (isReadableStreamLike(input)) {
@@ -1468,7 +1468,7 @@
     }
 
     function throwError(errorOrErrorFactory, scheduler) {
-        var errorFactory = isFunction$2(errorOrErrorFactory) ? errorOrErrorFactory : function () { return errorOrErrorFactory; };
+        var errorFactory = isFunction$3(errorOrErrorFactory) ? errorOrErrorFactory : function () { return errorOrErrorFactory; };
         var init = function (subscriber) { return subscriber.error(errorFactory()); };
         return new Observable(init);
     }
@@ -1659,7 +1659,7 @@
 
     function mergeMap(project, resultSelector, concurrent) {
         if (concurrent === void 0) { concurrent = Infinity; }
-        if (isFunction$2(resultSelector)) {
+        if (isFunction$3(resultSelector)) {
             return mergeMap(function (a, i) { return map$1(function (b, ii) { return resultSelector(a, b, i, ii); })(innerFrom(project(a, i))); }, concurrent);
         }
         else if (typeof resultSelector === 'number') {
@@ -1701,7 +1701,7 @@
                 return subscriber.next(e.length === 1 ? e[0] : e);
             };
             var retValue = addHandler(handler);
-            return isFunction$2(removeHandler) ? function () { return removeHandler(handler, retValue); } : undefined;
+            return isFunction$3(removeHandler) ? function () { return removeHandler(handler, retValue); } : undefined;
         });
     }
 
@@ -1867,7 +1867,7 @@
     }
 
     function concatMap(project, resultSelector) {
-        return isFunction$2(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
+        return isFunction$3(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
     }
 
     function concat() {
@@ -2089,7 +2089,7 @@
     }
 
     function tap(observerOrNext, error, complete) {
-        var tapObserver = isFunction$2(observerOrNext) || error || complete
+        var tapObserver = isFunction$3(observerOrNext) || error || complete
             ?
                 { next: observerOrNext, error: error, complete: complete }
             : observerOrNext;
@@ -2634,7 +2634,7 @@
      * @returns the `globalThis` object for the given environment.
      * @public
      */
-    function getGlobal() {
+    function getGlobal$1() {
         if (typeof self !== 'undefined') {
             return self;
         }
@@ -2663,7 +2663,7 @@
      * See the License for the specific language governing permissions and
      * limitations under the License.
      */
-    const getDefaultsFromGlobal = () => getGlobal().__FIREBASE_DEFAULTS__;
+    const getDefaultsFromGlobal = () => getGlobal$1().__FIREBASE_DEFAULTS__;
     /**
      * Attempt to read defaults from a JSON string provided to
      * process(.)env(.)__FIREBASE_DEFAULTS__ or a JSON file whose path is in
@@ -3133,7 +3133,7 @@
      *
      * @return true if ReactNative environment is detected.
      */
-    function isReactNative() {
+    function isReactNative$1() {
         return (typeof navigator === 'object' && navigator['product'] === 'ReactNative');
     }
     /** Detects Internet Explorer. */
@@ -9832,7 +9832,7 @@
             if (isMobileCordova()) {
                 stats['framework.cordova'] = 1;
             }
-            else if (isReactNative()) {
+            else if (isReactNative$1()) {
                 stats['framework.reactnative'] = 1;
             }
             this.reportStats(stats);
@@ -19393,7 +19393,7 @@
             this.longDelay = longDelay;
             // Internal error when improperly initialized.
             debugAssert(longDelay > shortDelay, 'Short delay should be less than long delay!');
-            this.isMobile = isMobileCordova() || isReactNative();
+            this.isMobile = isMobileCordova() || isReactNative$1();
         }
         get() {
             if (!_isOnline()) {
@@ -30526,8 +30526,9 @@
         registerVersion(F, M, "esm2020");
     }();
 
+    const productionApiKey = ["AIza", "SyB0TkZ83Fj0CIzn8AAmE-Osc92s3ER8hy8"].join("");
     const config = {
-        apiKey: "AIzaSyB0TkZ83Fj0CIzn8AAmE-Osc92s3ER8hy8",
+        apiKey: productionApiKey,
         authDomain: "neurosity-device.firebaseapp.com",
         databaseURL: "https://neurosity-device.firebaseio.com",
         projectId: "neurosity-device",
@@ -31547,16 +31548,14 @@
             this.firebaseUser.onUserClaimsChange().subscribe((userClaims) => {
                 this.userClaims = userClaims;
             });
-            this.onDeviceChange().subscribe(async (device) => {
+            this.onDeviceChange().subscribe((device) => {
                 if (this.firebaseDevice) {
-                    try {
-                        await this.firebaseDevice.disconnect();
-                    }
-                    catch (error) {
+                    this.firebaseDevice.disconnect().catch((error) => {
                         console.error("Error disconnecting from device", error);
-                    }
+                    });
                 }
                 if (!device) {
+                    this.firebaseDevice = undefined;
                     return;
                 }
                 this.firebaseDevice = new FirebaseDevice({
@@ -31843,6 +31842,7 @@
         calm: "7d47617d-a60a-41d1-8df6-cfb78d02ffeb",
         accelerometer: "84501dee-8665-4073-b111-bdecd69fb489",
         signalQuality: "cf28ed0c-20cd-48ed-93c5-ee2fb265099a",
+        signalQualityV2: "902ac5f3-ce59-4c11-94fa-437e89f90630",
         raw: "009cf0bb-b68d-4af1-a0e5-625f2eb964a6",
         rawUnfiltered: "5472432e-3313-4169-add8-6fcb29accb0e",
         psd: "d6684fb0-8518-40c0-8e88-4634e762435d",
@@ -31903,20 +31903,14 @@
     const metrics = {
         kinesis,
         predictions: kinesis,
-        channelAnalysis: channelNames,
         signalQuality: channelNames,
-        status: {
-            state: {},
-            battery: {},
-            charging: {},
-            connected: {},
-            connectedSince: {},
-            connectedLast: {},
-            updatingProgress: {},
-            simulate: {},
-            ssid: {}
+        signalQualityV2: {
+            timestamp: {},
+            overall: {},
+            byChannel: {}
         },
         accelerometer: {
+            timestamp: {},
             acceleration: {},
             inclination: {},
             orientation: {},
@@ -32354,6 +32348,13 @@
         return new Error(`${prefix}You are trying to access data with an OAuth token or API key without access to the following scopes: ${requiredScopes.join(", ")}.`);
     }
 
+    /**
+     * Create a bound version of a function with a specified `this` context
+     *
+     * @param {Function} fn - The function to bind
+     * @param {*} thisArg - The value to be passed as the `this` parameter
+     * @returns {Function} A new function that will call the original function with the specified `this` context
+     */
     function bind(fn, thisArg) {
       return function wrap() {
         return fn.apply(thisArg, arguments);
@@ -32362,29 +32363,30 @@
 
     // utils is a library of generic helper functions non-specific to axios
 
-    const {toString} = Object.prototype;
-    const {getPrototypeOf} = Object;
+    const { toString } = Object.prototype;
+    const { getPrototypeOf } = Object;
+    const { iterator, toStringTag } = Symbol;
 
-    const kindOf = (cache => thing => {
-        const str = toString.call(thing);
-        return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+    const kindOf = ((cache) => (thing) => {
+      const str = toString.call(thing);
+      return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
     })(Object.create(null));
 
     const kindOfTest = (type) => {
       type = type.toLowerCase();
-      return (thing) => kindOf(thing) === type
+      return (thing) => kindOf(thing) === type;
     };
 
-    const typeOfTest = type => thing => typeof thing === type;
+    const typeOfTest = (type) => (thing) => typeof thing === type;
 
     /**
-     * Determine if a value is an Array
+     * Determine if a value is a non-null object
      *
      * @param {Object} val The value to test
      *
      * @returns {boolean} True if value is an Array, otherwise false
      */
-    const {isArray} = Array;
+    const { isArray } = Array;
 
     /**
      * Determine if a value is undefined
@@ -32403,8 +32405,14 @@
      * @returns {boolean} True if value is a Buffer, otherwise false
      */
     function isBuffer(val) {
-      return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
-        && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+      return (
+        val !== null &&
+        !isUndefined(val) &&
+        val.constructor !== null &&
+        !isUndefined(val.constructor) &&
+        isFunction$2(val.constructor.isBuffer) &&
+        val.constructor.isBuffer(val)
+      );
     }
 
     /**
@@ -32416,7 +32424,6 @@
      */
     const isArrayBuffer = kindOfTest('ArrayBuffer');
 
-
     /**
      * Determine if a value is a view on an ArrayBuffer
      *
@@ -32426,10 +32433,10 @@
      */
     function isArrayBufferView(val) {
       let result;
-      if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
+      if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {
         result = ArrayBuffer.isView(val);
       } else {
-        result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
+        result = val && val.buffer && isArrayBuffer(val.buffer);
       }
       return result;
     }
@@ -32449,7 +32456,7 @@
      * @param {*} val The value to test
      * @returns {boolean} True if value is a Function, otherwise false
      */
-    const isFunction$1 = typeOfTest('function');
+    const isFunction$2 = typeOfTest('function');
 
     /**
      * Determine if a value is a Number
@@ -32475,7 +32482,7 @@
      * @param {*} thing The value to test
      * @returns {boolean} True if value is a Boolean, otherwise false
      */
-    const isBoolean = thing => thing === true || thing === false;
+    const isBoolean = (thing) => thing === true || thing === false;
 
     /**
      * Determine if a value is a plain Object
@@ -32490,7 +32497,34 @@
       }
 
       const prototype = getPrototypeOf(val);
-      return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);
+      return (
+        (prototype === null ||
+          prototype === Object.prototype ||
+          Object.getPrototypeOf(prototype) === null) &&
+        !(toStringTag in val) &&
+        !(iterator in val)
+      );
+    };
+
+    /**
+     * Determine if a value is an empty object (safely handles Buffers)
+     *
+     * @param {*} val The value to test
+     *
+     * @returns {boolean} True if value is an empty object, otherwise false
+     */
+    const isEmptyObject = (val) => {
+      // Early return for non-objects or Buffers to prevent RangeError
+      if (!isObject$1(val) || isBuffer(val)) {
+        return false;
+      }
+
+      try {
+        return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+      } catch (e) {
+        // Fallback for any other objects that might cause RangeError with Object.keys()
+        return false;
+      }
     };
 
     /**
@@ -32511,6 +32545,31 @@
      */
     const isFile = kindOfTest('File');
 
+    /**
+     * Determine if a value is a React Native Blob
+     * React Native "blob": an object with a `uri` attribute. Optionally, it can
+     * also have a `name` and `type` attribute to specify filename and content type
+     *
+     * @see https://github.com/facebook/react-native/blob/26684cf3adf4094eb6c405d345a75bf8c7c0bf88/Libraries/Network/FormData.js#L68-L71
+     * 
+     * @param {*} value The value to test
+     * 
+     * @returns {boolean} True if value is a React Native Blob, otherwise false
+     */
+    const isReactNativeBlob = (value) => {
+      return !!(value && typeof value.uri !== 'undefined');
+    };
+
+    /**
+     * Determine if environment is React Native
+     * ReactNative `FormData` has a non-standard `getParts()` method
+     * 
+     * @param {*} formData The formData to test
+     * 
+     * @returns {boolean} True if environment is React Native, otherwise false
+     */
+    const isReactNative = (formData) => formData && typeof formData.getParts !== 'undefined';
+
     /**
      * Determine if a value is a Blob
      *
@@ -32536,7 +32595,7 @@
      *
      * @returns {boolean} True if value is a Stream, otherwise false
      */
-    const isStream = (val) => isObject$1(val) && isFunction$1(val.pipe);
+    const isStream = (val) => isObject$1(val) && isFunction$2(val.pipe);
 
     /**
      * Determine if a value is a FormData
@@ -32545,17 +32604,28 @@
      *
      * @returns {boolean} True if value is an FormData, otherwise false
      */
+    function getGlobal() {
+      if (typeof globalThis !== 'undefined') return globalThis;
+      if (typeof self !== 'undefined') return self;
+      if (typeof window !== 'undefined') return window;
+      if (typeof global !== 'undefined') return global;
+      return {};
+    }
+
+    const G = getGlobal();
+    const FormDataCtor = typeof G.FormData !== 'undefined' ? G.FormData : undefined;
+
     const isFormData = (thing) => {
       let kind;
       return thing && (
-        (typeof FormData === 'function' && thing instanceof FormData) || (
-          isFunction$1(thing.append) && (
+        (FormDataCtor && thing instanceof FormDataCtor) || (
+          isFunction$2(thing.append) && (
             (kind = kindOf(thing)) === 'formdata' ||
             // detect form-data instance
-            (kind === 'object' && isFunction$1(thing.toString) && thing.toString() === '[object FormData]')
+            (kind === 'object' && isFunction$2(thing.toString) && thing.toString() === '[object FormData]')
           )
         )
-      )
+      );
     };
 
     /**
@@ -32567,6 +32637,13 @@
      */
     const isURLSearchParams = kindOfTest('URLSearchParams');
 
+    const [isReadableStream, isRequest, isResponse, isHeaders] = [
+      'ReadableStream',
+      'Request',
+      'Response',
+      'Headers',
+    ].map(kindOfTest);
+
     /**
      * Trim excess whitespace off the beginning and end of a string
      *
@@ -32574,9 +32651,9 @@
      *
      * @returns {String} The String freed of excess whitespace
      */
-    const trim = (str) => str.trim ?
-      str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
-
+    const trim = (str) => {
+      return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+    };
     /**
      * Iterate over an Array or an Object invoking a function for each item.
      *
@@ -32586,13 +32663,14 @@
      * 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 {Object|Array<unknown>} obj The object to iterate
      * @param {Function} fn The callback to invoke for each item
      *
-     * @param {Boolean} [allOwnKeys = false]
+     * @param {Object} [options]
+     * @param {Boolean} [options.allOwnKeys = false]
      * @returns {any}
      */
-    function forEach(obj, fn, {allOwnKeys = false} = {}) {
+    function forEach(obj, fn, { allOwnKeys = false } = {}) {
       // Don't bother if no value provided
       if (obj === null || typeof obj === 'undefined') {
         return;
@@ -32613,6 +32691,11 @@
           fn.call(null, obj[i], i, obj);
         }
       } else {
+        // Buffer check
+        if (isBuffer(obj)) {
+          return;
+        }
+
         // Iterate over object keys
         const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
         const len = keys.length;
@@ -32625,7 +32708,19 @@
       }
     }
 
+    /**
+     * Finds a key in an object, case-insensitive, returning the actual key name.
+     * Returns null if the object is a Buffer or if no match is found.
+     *
+     * @param {Object} obj - The object to search.
+     * @param {string} key - The key to find (case-insensitive).
+     * @returns {?string} The actual key name if found, otherwise null.
+     */
     function findKey(obj, key) {
+      if (isBuffer(obj)) {
+        return null;
+      }
+
       key = key.toLowerCase();
       const keys = Object.keys(obj);
       let i = keys.length;
@@ -32641,8 +32736,8 @@
 
     const _global = (() => {
       /*eslint no-undef:0*/
-      if (typeof globalThis !== "undefined") return globalThis;
-      return typeof self !== "undefined" ? self : (typeof window !== 'undefined' ? window : global)
+      if (typeof globalThis !== 'undefined') return globalThis;
+      return typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : global;
     })();
 
     const isContextDefined = (context) => !isUndefined(context) && context !== _global;
@@ -32657,7 +32752,7 @@
      * Example:
      *
      * ```js
-     * var result = merge({foo: 123}, {foo: 456});
+     * const result = merge({foo: 123}, {foo: 456});
      * console.log(result.foo); // outputs 456
      * ```
      *
@@ -32666,17 +32761,22 @@
      * @returns {Object} Result of all merge properties
      */
     function merge(/* obj1, obj2, obj3, ... */) {
-      const {caseless} = isContextDefined(this) && this || {};
+      const { caseless, skipUndefined } = (isContextDefined(this) && this) || {};
       const result = {};
       const assignValue = (val, key) => {
-        const targetKey = caseless && findKey(result, key) || key;
+        // Skip dangerous property names to prevent prototype pollution
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+          return;
+        }
+
+        const targetKey = (caseless && findKey(result, key)) || key;
         if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
           result[targetKey] = merge(result[targetKey], val);
         } else if (isPlainObject(val)) {
           result[targetKey] = merge({}, val);
         } else if (isArray(val)) {
           result[targetKey] = val.slice();
-        } else {
+        } else if (!skipUndefined || !isUndefined(val)) {
           result[targetKey] = val;
         }
       };
@@ -32694,17 +32794,32 @@
      * @param {Object} b The object to copy properties from
      * @param {Object} thisArg The object to bind function to
      *
-     * @param {Boolean} [allOwnKeys]
+     * @param {Object} [options]
+     * @param {Boolean} [options.allOwnKeys]
      * @returns {Object} The resulting value of object a
      */
-    const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
-      forEach(b, (val, key) => {
-        if (thisArg && isFunction$1(val)) {
-          a[key] = bind(val, thisArg);
-        } else {
-          a[key] = val;
-        }
-      }, {allOwnKeys});
+    const extend = (a, b, thisArg, { allOwnKeys } = {}) => {
+      forEach(
+        b,
+        (val, key) => {
+          if (thisArg && isFunction$2(val)) {
+            Object.defineProperty(a, key, {
+              value: bind(val, thisArg),
+              writable: true,
+              enumerable: true,
+              configurable: true,
+            });
+          } else {
+            Object.defineProperty(a, key, {
+              value: val,
+              writable: true,
+              enumerable: true,
+              configurable: true,
+            });
+          }
+        },
+        { allOwnKeys }
+      );
       return a;
     };
 
@@ -32716,7 +32831,7 @@
      * @returns {string} content value without BOM
      */
     const stripBOM = (content) => {
-      if (content.charCodeAt(0) === 0xFEFF) {
+      if (content.charCodeAt(0) === 0xfeff) {
         content = content.slice(1);
       }
       return content;
@@ -32733,9 +32848,14 @@
      */
     const inherits = (constructor, superConstructor, props, descriptors) => {
       constructor.prototype = Object.create(superConstructor.prototype, descriptors);
-      constructor.prototype.constructor = constructor;
+      Object.defineProperty(constructor.prototype, 'constructor', {
+        value: constructor,
+        writable: true,
+        enumerable: false,
+        configurable: true,
+      });
       Object.defineProperty(constructor, 'super', {
-        value: superConstructor.prototype
+        value: superConstructor.prototype,
       });
       props && Object.assign(constructor.prototype, props);
     };
@@ -32794,7 +32914,6 @@
       return lastIndex !== -1 && lastIndex === position;
     };
 
-
     /**
      * Returns new array from array like object or null if failed
      *
@@ -32823,9 +32942,9 @@
      * @returns {Array}
      */
     // eslint-disable-next-line func-names
-    const isTypedArray = (TypedArray => {
+    const isTypedArray = ((TypedArray) => {
       // eslint-disable-next-line func-names
-      return thing => {
+      return (thing) => {
         return TypedArray && thing instanceof TypedArray;
       };
     })(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));
@@ -32839,13 +32958,13 @@
      * @returns {void}
      */
     const forEachEntry = (obj, fn) => {
-      const generator = obj && obj[Symbol.iterator];
+      const generator = obj && obj[iterator];
 
-      const iterator = generator.call(obj);
+      const _iterator = generator.call(obj);
 
       let result;
 
-      while ((result = iterator.next()) && !result.done) {
+      while ((result = _iterator.next()) && !result.done) {
         const pair = result.value;
         fn.call(obj, pair[0], pair[1]);
       }
@@ -32873,16 +32992,18 @@
     /* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */
     const isHTMLForm = kindOfTest('HTMLFormElement');
 
-    const toCamelCase = str => {
-      return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,
-        function replacer(m, p1, p2) {
-          return p1.toUpperCase() + p2;
-        }
-      );
+    const toCamelCase = (str) => {
+      return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
+        return p1.toUpperCase() + p2;
+      });
     };
 
     /* Creating a function that will check if an object has a property. */
-    const hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);
+    const hasOwnProperty = (
+      ({ hasOwnProperty }) =>
+      (obj, prop) =>
+        hasOwnProperty.call(obj, prop)
+    )(Object.prototype);
 
     /**
      * Determine if a value is a RegExp object
@@ -32915,13 +33036,13 @@
     const freezeMethods = (obj) => {
       reduceDescriptors(obj, (descriptor, name) => {
         // skip restricted props in strict mode
-        if (isFunction$1(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
+        if (isFunction$2(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
           return false;
         }
 
         const value = obj[name];
 
-        if (!isFunction$1(value)) return;
+        if (!isFunction$2(value)) return;
 
         descriptor.enumerable = false;
 
@@ -32932,17 +33053,25 @@
 
         if (!descriptor.set) {
           descriptor.set = () => {
-            throw Error('Can not rewrite read-only method \'' + name + '\'');
+            throw Error("Can not rewrite read-only method '" + name + "'");
           };
         }
       });
     };
 
+    /**
+     * Converts an array or a delimited string into an object set with values as keys and true as values.
+     * Useful for fast membership checks.
+     *
+     * @param {Array|string} arrayOrString - The array or string to convert.
+     * @param {string} delimiter - The delimiter to use if input is a string.
+     * @returns {Object} An object with keys from the array or string, values set to true.
+     */
     const toObjectSet = (arrayOrString, delimiter) => {
       const obj = {};
 
       const define = (arr) => {
-        arr.forEach(value => {
+        arr.forEach((value) => {
           obj[value] = true;
         });
       };
@@ -32955,28 +33084,7 @@
     const noop = () => {};
 
     const toFiniteNumber = (value, defaultValue) => {
-      value = +value;
-      return Number.isFinite(value) ? value : defaultValue;
-    };
-
-    const ALPHA = 'abcdefghijklmnopqrstuvwxyz';
-
-    const DIGIT = '0123456789';
-
-    const ALPHABET = {
-      DIGIT,
-      ALPHA,
-      ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
-    };
-
-    const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
-      let str = '';
-      const {length} = alphabet;
-      while (size--) {
-        str += alphabet[Math.random() * length|0];
-      }
-
-      return str;
+      return value != null && Number.isFinite((value = +value)) ? value : defaultValue;
     };
 
     /**
@@ -32987,20 +33095,35 @@
      * @returns {boolean}
      */
     function isSpecCompliantForm(thing) {
-      return !!(thing && isFunction$1(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);
+      return !!(
+        thing &&
+        isFunction$2(thing.append) &&
+        thing[toStringTag] === 'FormData' &&
+        thing[iterator]
+      );
     }
 
+    /**
+     * Recursively converts an object to a JSON-compatible object, handling circular references and Buffers.
+     *
+     * @param {Object} obj - The object to convert.
+     * @returns {Object} The JSON-compatible object.
+     */
     const toJSONObject = (obj) => {
       const stack = new Array(10);
 
       const visit = (source, i) => {
-
         if (isObject$1(source)) {
           if (stack.indexOf(source) >= 0) {
             return;
           }
 
-          if(!('toJSON' in source)) {
+          //Buffer check
+          if (isBuffer(source)) {
+            return source;
+          }
+
+          if (!('toJSON' in source)) {
             stack[i] = source;
             const target = isArray(source) ? [] : {};
 
@@ -33021,10 +33144,76 @@
       return visit(obj, 0);
     };
 
+    /**
+     * Determines if a value is an async function.
+     *
+     * @param {*} thing - The value to test.
+     * @returns {boolean} True if value is an async function, otherwise false.
+     */
     const isAsyncFn = kindOfTest('AsyncFunction');
 
+    /**
+     * Determines if a value is thenable (has then and catch methods).
+     *
+     * @param {*} thing - The value to test.
+     * @returns {boolean} True if value is thenable, otherwise false.
+     */
     const isThenable = (thing) =>
-      thing && (isObject$1(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
+      thing &&
+      (isObject$1(thing) || isFunction$2(thing)) &&
+      isFunction$2(thing.then) &&
+      isFunction$2(thing.catch);
+
+    // original code
+    // https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
+
+    /**
+     * Provides a cross-platform setImmediate implementation.
+     * Uses native setImmediate if available, otherwise falls back to postMessage or setTimeout.
+     *
+     * @param {boolean} setImmediateSupported - Whether setImmediate is supported.
+     * @param {boolean} postMessageSupported - Whether postMessage is supported.
+     * @returns {Function} A function to schedule a callback asynchronously.
+     */
+    const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
+      if (setImmediateSupported) {
+        return setImmediate;
+      }
+
+      return postMessageSupported
+        ? ((token, callbacks) => {
+            _global.addEventListener(
+              'message',
+              ({ source, data }) => {
+                if (source === _global && data === token) {
+                  callbacks.length && callbacks.shift()();
+                }
+              },
+              false
+            );
+
+            return (cb) => {
+              callbacks.push(cb);
+              _global.postMessage(token, '*');
+            };
+          })(`axios@${Math.random()}`, [])
+        : (cb) => setTimeout(cb);
+    })(typeof setImmediate === 'function', isFunction$2(_global.postMessage));
+
+    /**
+     * Schedules a microtask or asynchronous callback as soon as possible.
+     * Uses queueMicrotask if available, otherwise falls back to process.nextTick or _setImmediate.
+     *
+     * @type {Function}
+     */
+    const asap =
+      typeof queueMicrotask !== 'undefined'
+        ? queueMicrotask.bind(_global)
+        : (typeof process !== 'undefined' && process.nextTick) || _setImmediate;
+
+    // *********************
+
+    const isIterable = (thing) => thing != null && isFunction$2(thing[iterator]);
 
     var utils$1 = {
       isArray,
@@ -33037,12 +33226,19 @@
       isBoolean,
       isObject: isObject$1,
       isPlainObject,
+      isEmptyObject,
+      isReadableStream,
+      isRequest,
+      isResponse,
+      isHeaders,
       isUndefined,
       isDate,
       isFile,
+      isReactNativeBlob,
+      isReactNative,
       isBlob,
       isRegExp,
-      isFunction: isFunction$1,
+      isFunction: isFunction$2,
       isStream,
       isURLSearchParams,
       isTypedArray,
@@ -33072,44 +33268,66 @@
       findKey,
       global: _global,
       isContextDefined,
-      ALPHABET,
-      generateString,
       isSpecCompliantForm,
       toJSONObject,
       isAsyncFn,
-      isThenable
+      isThenable,
+      setImmediate: _setImmediate,
+      asap,
+      isIterable,
     };
 
-    /**
-     * Create an Error with the specified message, config, error code, request and response.
-     *
-     * @param {string} message The error message.
-     * @param {string} [code] The error code (for example, 'ECONNABORTED').
-     * @param {Object} [config] The config.
-     * @param {Object} [request] The request.
-     * @param {Object} [response] The response.
-     *
-     * @returns {Error} The created error.
-     */
-    function AxiosError$1(message, code, config, request, response) {
-      Error.call(this);
+    let AxiosError$1 = class AxiosError extends Error {
+      static from(error, code, config, request, response, customProps) {
+        const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
+        axiosError.cause = error;
+        axiosError.name = error.name;
 
-      if (Error.captureStackTrace) {
-        Error.captureStackTrace(this, this.constructor);
-      } else {
-        this.stack = (new Error()).stack;
+        // Preserve status from the original error if not already set from response
+        if (error.status != null && axiosError.status == null) {
+          axiosError.status = error.status;
+        }
+
+        customProps && Object.assign(axiosError, customProps);
+        return axiosError;
       }
 
-      this.message = message;
-      this.name = 'AxiosError';
-      code && (this.code = code);
-      config && (this.config = config);
-      request && (this.request = request);
-      response && (this.response = response);
-    }
+        /**
+         * Create an Error with the specified message, config, error code, request and response.
+         *
+         * @param {string} message The error message.
+         * @param {string} [code] The error code (for example, 'ECONNABORTED').
+         * @param {Object} [config] The config.
+         * @param {Object} [request] The request.
+         * @param {Object} [response] The response.
+         *
+         * @returns {Error} The created error.
+         */
+        constructor(message, code, config, request, response) {
+          super(message);
+          
+          // Make message enumerable to maintain backward compatibility
+          // The native Error constructor sets message as non-enumerable,
+          // but axios < v1.13.3 had it as enumerable
+          Object.defineProperty(this, 'message', {
+              value: message,
+              enumerable: true,
+              writable: true,
+              configurable: true
+          });
+          
+          this.name = 'AxiosError';
+          this.isAxiosError = true;
+          code && (this.code = code);
+          config && (this.config = config);
+          request && (this.request = request);
+          if (response) {
+              this.response = response;
+              this.status = response.status;
+          }
+        }
 
-    utils$1.inherits(AxiosError$1, Error, {
-      toJSON: function toJSON() {
+      toJSON() {
         return {
           // Standard
           message: this.message,
@@ -33125,56 +33343,25 @@
           // Axios
           config: utils$1.toJSONObject(this.config),
           code: this.code,
-          status: this.response && this.response.status ? this.response.status : null
+          status: this.status,
         };
       }
-    });
-
-    const prototype$1 = AxiosError$1.prototype;
-    const 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',
-      'ERR_NOT_SUPPORT',
-      'ERR_INVALID_URL'
-    // eslint-disable-next-line func-names
-    ].forEach(code => {
-      descriptors[code] = {value: code};
-    });
-
-    Object.defineProperties(AxiosError$1, descriptors);
-    Object.defineProperty(prototype$1, 'isAxiosError', {value: true});
-
-    // eslint-disable-next-line func-names
-    AxiosError$1.from = (error, code, config, request, response, customProps) => {
-      const axiosError = Object.create(prototype$1);
-
-      utils$1.toFlatObject(error, axiosError, function filter(obj) {
-        return obj !== Error.prototype;
-      }, prop => {
-        return prop !== 'isAxiosError';
-      });
-
-      AxiosError$1.call(axiosError, error.message, code, config, request, response);
-
-      axiosError.cause = error;
-
-      axiosError.name = error.name;
-
-      customProps && Object.assign(axiosError, customProps);
-
-      return axiosError;
     };
 
+    // This can be changed to static properties as soon as the parser options in .eslint.cjs are updated.
+    AxiosError$1.ERR_BAD_OPTION_VALUE = 'ERR_BAD_OPTION_VALUE';
+    AxiosError$1.ERR_BAD_OPTION = 'ERR_BAD_OPTION';
+    AxiosError$1.ECONNABORTED = 'ECONNABORTED';
+    AxiosError$1.ETIMEDOUT = 'ETIMEDOUT';
+    AxiosError$1.ERR_NETWORK = 'ERR_NETWORK';
+    AxiosError$1.ERR_FR_TOO_MANY_REDIRECTS = 'ERR_FR_TOO_MANY_REDIRECTS';
+    AxiosError$1.ERR_DEPRECATED = 'ERR_DEPRECATED';
+    AxiosError$1.ERR_BAD_RESPONSE = 'ERR_BAD_RESPONSE';
+    AxiosError$1.ERR_BAD_REQUEST = 'ERR_BAD_REQUEST';
+    AxiosError$1.ERR_CANCELED = 'ERR_CANCELED';
+    AxiosError$1.ERR_NOT_SUPPORT = 'ERR_NOT_SUPPORT';
+    AxiosError$1.ERR_INVALID_URL = 'ERR_INVALID_URL';
+
     // eslint-disable-next-line strict
     var httpAdapter = null;
 
@@ -33211,11 +33398,14 @@
      */
     function renderKey(path, key, dots) {
       if (!path) return key;
-      return path.concat(key).map(function each(token, i) {
-        // eslint-disable-next-line no-param-reassign
-        token = removeBrackets(token);
-        return !dots && i ? '[' + token + ']' : token;
-      }).join(dots ? '.' : '');
+      return path
+        .concat(key)
+        .map(function each(token, i) {
+          // eslint-disable-next-line no-param-reassign
+          token = removeBrackets(token);
+          return !dots && i ? '[' + token + ']' : token;
+        })
+        .join(dots ? '.' : '');
     }
 
     /**
@@ -33265,21 +33455,26 @@
       formData = formData || new (FormData)();
 
       // eslint-disable-next-line no-param-reassign
-      options = utils$1.toFlatObject(options, {
-        metaTokens: true,
-        dots: false,
-        indexes: false
-      }, false, function defined(option, source) {
-        // eslint-disable-next-line no-eq-null,eqeqeq
-        return !utils$1.isUndefined(source[option]);
-      });
+      options = utils$1.toFlatObject(
+        options,
+        {
+          metaTokens: true,
+          dots: false,
+          indexes: false,
+        },
+        false,
+        function defined(option, source) {
+          // eslint-disable-next-line no-eq-null,eqeqeq
+          return !utils$1.isUndefined(source[option]);
+        }
+      );
 
       const metaTokens = options.metaTokens;
       // eslint-disable-next-line no-use-before-define
       const visitor = options.visitor || defaultVisitor;
       const dots = options.dots;
       const indexes = options.indexes;
-      const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
+      const _Blob = options.Blob || (typeof Blob !== 'undefined' && Blob);
       const useBlob = _Blob && utils$1.isSpecCompliantForm(formData);
 
       if (!utils$1.isFunction(visitor)) {
@@ -33293,6 +33488,10 @@
           return value.toISOString();
         }
 
+        if (utils$1.isBoolean(value)) {
+          return value.toString();
+        }
+
         if (!useBlob && utils$1.isBlob(value)) {
           throw new AxiosError$1('Blob is not supported. Use a Buffer instead.');
         }
@@ -33317,6 +33516,11 @@
       function defaultVisitor(value, key, path) {
         let arr = value;
 
+        if (utils$1.isReactNative(formData) && utils$1.isReactNativeBlob(value)) {
+          formData.append(renderKey(path, key, dots), convertValue(value));
+          return false;
+        }
+
         if (value && !path && typeof value === 'object') {
           if (utils$1.endsWith(key, '{}')) {
             // eslint-disable-next-line no-param-reassign
@@ -33325,17 +33529,22 @@
             value = JSON.stringify(value);
           } else if (
             (utils$1.isArray(value) && isFlatArray(value)) ||
-            ((utils$1.isFileList(value) || utils$1.endsWith(key, '[]')) && (arr = utils$1.toArray(value))
-            )) {
+            ((utils$1.isFileList(value) || utils$1.endsWith(key, '[]')) && (arr = utils$1.toArray(value)))
+          ) {
             // eslint-disable-next-line no-param-reassign
             key = removeBrackets(key);
 
             arr.forEach(function each(el, index) {
-              !(utils$1.isUndefined(el) || el === null) && formData.append(
-                // eslint-disable-next-line no-nested-ternary
-                indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),
-                convertValue(el)
-              );
+              !(utils$1.isUndefined(el) || el === null) &&
+                formData.append(
+                  // eslint-disable-next-line no-nested-ternary
+                  indexes === true
+                    ? renderKey([key], index, dots)
+                    : indexes === null
+                      ? key
+                      : key + '[]',
+                  convertValue(el)
+                );
             });
             return false;
           }
@@ -33355,7 +33564,7 @@
       const exposedHelpers = Object.assign(predicates, {
         defaultVisitor,
         convertValue,
-        isVisitable
+        isVisitable,
       });
 
       function build(value, path) {
@@ -33368,9 +33577,9 @@
         stack.push(value);
 
         utils$1.forEach(value, function each(el, key) {
-          const result = !(utils$1.isUndefined(el) || el === null) && visitor.call(
-            formData, el, utils$1.isString(key) ? key.trim() : key, path, exposedHelpers
-          );
+          const result =
+            !(utils$1.isUndefined(el) || el === null) &&
+            visitor.call(formData, el, utils$1.isString(key) ? key.trim() : key, path, exposedHelpers);
 
           if (result === true) {
             build(el, path ? path.concat(key) : [key]);
@@ -33405,7 +33614,7 @@
         ')': '%29',
         '~': '%7E',
         '%20': '+',
-        '%00': '\x00'
+        '%00': '\x00',
       };
       return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
         return charMap[match];
@@ -33433,31 +33642,33 @@
     };
 
     prototype.toString = function toString(encoder) {
-      const _encode = encoder ? function(value) {
-        return encoder.call(this, value, encode$1);
-      } : encode$1;
+      const _encode = encoder
+        ? function (value) {
+            return encoder.call(this, value, encode$1);
+          }
+        : encode$1;
 
-      return this._pairs.map(function each(pair) {
-        return _encode(pair[0]) + '=' + _encode(pair[1]);
-      }, '').join('&');
+      return this._pairs
+        .map(function each(pair) {
+          return _encode(pair[0]) + '=' + _encode(pair[1]);
+        }, '')
+        .join('&');
     };
 
     /**
-     * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
-     * URI encoded counterparts
+     * It replaces URL-encoded forms of `:`, `$`, `,`, and spaces with
+     * their plain counterparts (`:`, `$`, `,`, `+`).
      *
      * @param {string} val The value to be encoded.
      *
      * @returns {string} The encoded value.
      */
     function encode(val) {
-      return encodeURIComponent(val).
-        replace(/%3A/gi, ':').
-        replace(/%24/g, '$').
-        replace(/%2C/gi, ',').
-        replace(/%20/g, '+').
-        replace(/%5B/gi, '[').
-        replace(/%5D/gi, ']');
+      return encodeURIComponent(val)
+        .replace(/%3A/gi, ':')
+        .replace(/%24/g, '$')
+        .replace(/%2C/gi, ',')
+        .replace(/%20/g, '+');
     }
 
     /**
@@ -33465,32 +33676,37 @@
      *
      * @param {string} url The base of the url (e.g., http://www.google.com)
      * @param {object} [params] The params to be appended
-     * @param {?object} options
+     * @param {?(object|Function)} options
      *
      * @returns {string} The formatted url
      */
     function buildURL(url, params, options) {
-      /*eslint no-param-reassign:0*/
       if (!params) {
         return url;
       }
-      
-      const _encode = options && options.encode || encode;
 
-      const serializeFn = options && options.serialize;
+      const _encode = (options && options.encode) || encode;
+
+      const _options = utils$1.isFunction(options)
+        ? {
+            serialize: options,
+          }
+        : options;
+
+      const serializeFn = _options && _options.serialize;
 
       let serializedParams;
 
       if (serializeFn) {
-        serializedParams = serializeFn(params, options);
+        serializedParams = serializeFn(params, _options);
       } else {
-        serializedParams = utils$1.isURLSearchParams(params) ?
-          params.toString() :
-          new AxiosURLSearchParams(params, options).toString(_encode);
+        serializedParams = utils$1.isURLSearchParams(params)
+          ? params.toString()
+          : new AxiosURLSearchParams(params, _options).toString(_encode);
       }
 
       if (serializedParams) {
-        const hashmarkIndex = url.indexOf("#");
+        const hashmarkIndex = url.indexOf('#');
 
         if (hashmarkIndex !== -1) {
           url = url.slice(0, hashmarkIndex);
@@ -33511,6 +33727,7 @@
        *
        * @param {Function} fulfilled The function to handle `then` for a `Promise`
        * @param {Function} rejected The function to handle `reject` for a `Promise`
+       * @param {Object} options The options for the interceptor, synchronous and runWhen
        *
        * @return {Number} An ID used to remove interceptor later
        */
@@ -33519,7 +33736,7 @@
           fulfilled,
           rejected,
           synchronous: options ? options.synchronous : false,
-          runWhen: options ? options.runWhen : null
+          runWhen: options ? options.runWhen : null,
         });
         return this.handlers.length - 1;
       }
@@ -33529,7 +33746,7 @@
        *
        * @param {Number} id The ID that was returned by `use`
        *
-       * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+       * @returns {void}
        */
       eject(id) {
         if (this.handlers[id]) {
@@ -33570,7 +33787,8 @@
     var transitionalDefaults = {
       silentJSONParsing: true,
       forcedJSONParsing: true,
-      clarifyTimeoutError: false
+      clarifyTimeoutError: false,
+      legacyInterceptorReqResOrdering: true,
     };
 
     var URLSearchParams$1 = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;
@@ -33584,13 +33802,15 @@
       classes: {
         URLSearchParams: URLSearchParams$1,
         FormData: FormData$1,
-        Blob: Blob$1
+        Blob: Blob$1,
       },
-      protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
+      protocols: ['http', 'https', 'file', 'blob', 'url', 'data'],
     };
 
     const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';
 
+    const _navigator = (typeof navigator === 'object' && navigator) || undefined;
+
     /**
      * Determine if we're running in a standard browser environment
      *
@@ -33608,10 +33828,9 @@
      *
      * @returns {boolean}
      */
-    const hasStandardBrowserEnv = (
-      (product) => {
-        return hasBrowserEnv && ['ReactNative', 'NativeScript', 'NS'].indexOf(product) < 0
-      })(typeof navigator !== 'undefined' && navigator.product);
+    const hasStandardBrowserEnv =
+      hasBrowserEnv &&
+      (!_navigator || ['ReactNative', 'NativeScript', 'NS'].indexOf(_navigator.product) < 0);
 
     /**
      * Determine if we're running in a standard browser webWorker environment
@@ -33631,29 +33850,34 @@
       );
     })();
 
+    const origin = (hasBrowserEnv && window.location.href) || 'http://localhost';
+
     var utils = /*#__PURE__*/Object.freeze({
         __proto__: null,
         hasBrowserEnv: hasBrowserEnv,
         hasStandardBrowserEnv: hasStandardBrowserEnv,
-        hasStandardBrowserWebWorkerEnv: hasStandardBrowserWebWorkerEnv
+        hasStandardBrowserWebWorkerEnv: hasStandardBrowserWebWorkerEnv,
+        navigator: _navigator,
+        origin: origin
     });
 
     var platform = {
       ...utils,
-      ...platform$1
+      ...platform$1,
     };
 
     function toURLEncodedForm(data, options) {
-      return toFormData$1(data, new platform.classes.URLSearchParams(), Object.assign({
-        visitor: function(value, key, path, helpers) {
+      return toFormData$1(data, new platform.classes.URLSearchParams(), {
+        visitor: function (value, key, path, helpers) {
           if (platform.isNode && utils$1.isBuffer(value)) {
             this.append(key, value.toString('base64'));
             return false;
           }
 
           return helpers.defaultVisitor.apply(this, arguments);
-        }
-      }, options));
+        },
+        ...options,
+      });
     }
 
     /**
@@ -33668,7 +33892,7 @@
       // foo.x.y.z
       // foo-x-y-z
       // foo x y z
-      return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map(match => {
+      return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
         return match[0] === '[]' ? '' : match[1] || match[0];
       });
     }
@@ -33703,6 +33927,9 @@
     function formDataToJSON(formData) {
       function buildPath(path, value, target, index) {
         let name = path[index++];
+
+        if (name === '__proto__') return true;
+
         const isNumericKey = Number.isFinite(+name);
         const isLast = index >= path.length;
         name = !name && utils$1.isArray(target) ? target.length : name;
@@ -33769,94 +33996,107 @@
     }
 
     const defaults = {
-
       transitional: transitionalDefaults,
 
-      adapter: ['xhr', 'http'],
+      adapter: ['xhr', 'http', 'fetch'],
 
-      transformRequest: [function transformRequest(data, headers) {
-        const contentType = headers.getContentType() || '';
-        const hasJSONContentType = contentType.indexOf('application/json') > -1;
-        const isObjectPayload = utils$1.isObject(data);
+      transformRequest: [
+        function transformRequest(data, headers) {
+          const contentType = headers.getContentType() || '';
+          const hasJSONContentType = contentType.indexOf('application/json') > -1;
+          const isObjectPayload = utils$1.isObject(data);
 
-        if (isObjectPayload && utils$1.isHTMLForm(data)) {
-          data = new FormData(data);
-        }
+          if (isObjectPayload && utils$1.isHTMLForm(data)) {
+            data = new FormData(data);
+          }
+
+          const isFormData = utils$1.isFormData(data);
 
-        const isFormData = utils$1.isFormData(data);
+          if (isFormData) {
+            return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
+          }
 
-        if (isFormData) {
-          if (!hasJSONContentType) {
+          if (
+            utils$1.isArrayBuffer(data) ||
+            utils$1.isBuffer(data) ||
+            utils$1.isStream(data) ||
+            utils$1.isFile(data) ||
+            utils$1.isBlob(data) ||
+            utils$1.isReadableStream(data)
+          ) {
             return data;
           }
-          return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
-        }
+          if (utils$1.isArrayBufferView(data)) {
+            return data.buffer;
+          }
+          if (utils$1.isURLSearchParams(data)) {
+            headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
+            return data.toString();
+          }
 
-        if (utils$1.isArrayBuffer(data) ||
-          utils$1.isBuffer(data) ||
-          utils$1.isStream(data) ||
-          utils$1.isFile(data) ||
-          utils$1.isBlob(data)
-        ) {
-          return data;
-        }
-        if (utils$1.isArrayBufferView(data)) {
-          return data.buffer;
-        }
-        if (utils$1.isURLSearchParams(data)) {
-          headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
-          return data.toString();
-        }
+          let isFileList;
 
-        let isFileList;
+          if (isObjectPayload) {
+            if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
+              return toURLEncodedForm(data, this.formSerializer).toString();
+            }
 
-        if (isObjectPayload) {
-          if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
-            return toURLEncodedForm(data, this.formSerializer).toString();
-          }
+            if (
+              (isFileList = utils$1.isFileList(data)) ||
+              contentType.indexOf('multipart/form-data') > -1
+            ) {
+              const _FormData = this.env && this.env.FormData;
 
-          if ((isFileList = utils$1.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
-            const _FormData = this.env && this.env.FormData;
+              return toFormData$1(
+                isFileList ? { 'files[]': data } : data,
+                _FormData && new _FormData(),
+                this.formSerializer
+              );
+            }
+          }
 
-            return toFormData$1(
-              isFileList ? {'files[]': data} : data,
-              _FormData && new _FormData(),
-              this.formSerializer
-            );
+          if (isObjectPayload || hasJSONContentType) {
+            headers.setContentType('application/json', false);
+            return stringifySafely(data);
           }
-        }
 
-        if (isObjectPayload || hasJSONContentType ) {
-          headers.setContentType('application/json', false);
-          return stringifySafely(data);
-        }
+          return data;
+        },
+      ],
 
-        return data;
-      }],
+      transformResponse: [
+        function transformResponse(data) {
+          const transitional = this.transitional || defaults.transitional;
+          const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+          const JSONRequested = this.responseType === 'json';
 
-      transformResponse: [function transformResponse(data) {
-        const transitional = this.transitional || defaults.transitional;
-        const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
-        const JSONRequested = this.responseType === 'json';
+          if (utils$1.isResponse(data) || utils$1.isReadableStream(data)) {
+            return data;
+          }
 
-        if (data && utils$1.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {
-          const silentJSONParsing = transitional && transitional.silentJSONParsing;
-          const strictJSONParsing = !silentJSONParsing && JSONRequested;
+          if (
+            data &&
+            utils$1.isString(data) &&
+            ((forcedJSONParsing && !this.responseType) || JSONRequested)
+          ) {
+            const silentJSONParsing = transitional && transitional.silentJSONParsing;
+            const strictJSONParsing = !silentJSONParsing && JSONRequested;
 
-          try {
-            return JSON.parse(data);
-          } catch (e) {
-            if (strictJSONParsing) {
-              if (e.name === 'SyntaxError') {
-                throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
+            try {
+              return JSON.parse(data, this.parseReviver);
+            } catch (e) {
+              if (strictJSONParsing) {
+                if (e.name === 'SyntaxError') {
+                  throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
+                }
+                throw e;
               }
-              throw e;
             }
           }
-        }
 
-        return data;
-      }],
+          return data;
+        },
+      ],
 
       /**
        * A timeout in milliseconds to abort a request. If set to 0 (default) a
@@ -33872,7 +34112,7 @@
 
       env: {
         FormData: platform.classes.FormData,
-        Blob: platform.classes.Blob
+        Blob: platform.classes.Blob,
       },
 
       validateStatus: function validateStatus(status) {
@@ -33881,10 +34121,10 @@
 
       headers: {
         common: {
-          'Accept': 'application/json, text/plain, */*',
-          'Content-Type': undefined
-        }
-      }
+          Accept: 'application/json, text/plain, */*',
+          'Content-Type': undefined,
+        },
+      },
     };
 
     utils$1.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {
@@ -33894,10 +34134,23 @@
     // RawAxiosHeaders whose duplicates are ignored by node
     // c.f. https://nodejs.org/api/http.html#http_message_headers
     const ignoreDuplicateOf = utils$1.toObjectSet([
-      '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'
+      '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',
     ]);
 
     /**
@@ -33914,47 +34167,81 @@
      *
      * @returns {Object} Headers parsed into an object
      */
-    var parseHeaders = rawHeaders => {
+    var parseHeaders = (rawHeaders) => {
       const parsed = {};
       let key;
       let val;
       let i;
 
-      rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
-        i = line.indexOf(':');
-        key = line.substring(0, i).trim().toLowerCase();
-        val = line.substring(i + 1).trim();
+      rawHeaders &&
+        rawHeaders.split('\n').forEach(function parser(line) {
+          i = line.indexOf(':');
+          key = line.substring(0, i).trim().toLowerCase();
+          val = line.substring(i + 1).trim();
 
-        if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
-          return;
-        }
+          if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
+            return;
+          }
 
-        if (key === 'set-cookie') {
-          if (parsed[key]) {
-            parsed[key].push(val);
+          if (key === 'set-cookie') {
+            if (parsed[key]) {
+              parsed[key].push(val);
+            } else {
+              parsed[key] = [val];
+            }
           } else {
-            parsed[key] = [val];
+            parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
           }
-        } else {
-          parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
-        }
-      });
+        });
 
       return parsed;
     };
 
     const $internals = Symbol('internals');
 
+    const isValidHeaderValue = (value) => !/[\r\n]/.test(value);
+
+    function assertValidHeaderValue(value, header) {
+      if (value === false || value == null) {
+        return;
+      }
+
+      if (utils$1.isArray(value)) {
+        value.forEach((v) => assertValidHeaderValue(v, header));
+        return;
+      }
+
+      if (!isValidHeaderValue(String(value))) {
+        throw new Error(`Invalid character in header content ["${header}"]`);
+      }
+    }
+
     function normalizeHeader(header) {
       return header && String(header).trim().toLowerCase();
     }
 
+    function stripTrailingCRLF(str) {
+      let end = str.length;
+
+      while (end > 0) {
+        const charCode = str.charCodeAt(end - 1);
+
+        if (charCode !== 10 && charCode !== 13) {
+          break;
+        }
+
+        end -= 1;
+      }
+
+      return end === str.length ? str : str.slice(0, end);
+    }
+
     function normalizeValue(value) {
       if (value === false || value == null) {
         return value;
       }
 
-      return utils$1.isArray(value) ? value.map(normalizeValue) : String(value);
+      return utils$1.isArray(value) ? value.map(normalizeValue) : stripTrailingCRLF(String(value));
     }
 
     function parseTokens(str) {
@@ -33992,8 +34279,10 @@
     }
 
     function formatHeader(header) {
-      return header.trim()
-        .toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
+      return header
+        .trim()
+        .toLowerCase()
+        .replace(/([a-z\d])(\w*)/g, (w, char, str) => {
           return char.toUpperCase() + str;
         });
     }
@@ -34001,12 +34290,12 @@
     function buildAccessors(obj, header) {
       const accessorName = utils$1.toCamelCase(' ' + header);
 
-      ['get', 'set', 'has'].forEach(methodName => {
+      ['get', 'set', 'has'].forEach((methodName) => {
         Object.defineProperty(obj, methodName + accessorName, {
-          value: function(arg1, arg2, arg3) {
+          value: function (arg1, arg2, arg3) {
             return this[methodName].call(this, header, arg1, arg2, arg3);
           },
-          configurable: true
+          configurable: true,
         });
       });
     }
@@ -34028,7 +34317,13 @@
 
           const key = utils$1.findKey(self, lHeader);
 
-          if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {
+          if (
+            !key ||
+            self[key] === undefined ||
+            _rewrite === true ||
+            (_rewrite === undefined && self[key] !== false)
+          ) {
+            assertValidHeaderValue(_value, _header);
             self[key || _header] = normalizeValue(_value);
           }
         }
@@ -34038,8 +34333,25 @@
 
         if (utils$1.isPlainObject(header) || header instanceof this.constructor) {
           setHeaders(header, valueOrRewrite);
-        } else if(utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
+        } else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
           setHeaders(parseHeaders(header), valueOrRewrite);
+        } else if (utils$1.isObject(header) && utils$1.isIterable(header)) {
+          let obj = {},
+            dest,
+            key;
+          for (const entry of header) {
+            if (!utils$1.isArray(entry)) {
+              throw TypeError('Object iterator must return a key-value pair');
+            }
+
+            obj[(key = entry[0])] = (dest = obj[key])
+              ? utils$1.isArray(dest)
+                ? [...dest, entry[1]]
+                : [dest, entry[1]]
+              : entry[1];
+          }
+
+          setHeaders(obj, valueOrRewrite);
         } else {
           header != null && setHeader(valueOrRewrite, header, rewrite);
         }
@@ -34083,7 +34395,11 @@
         if (header) {
           const key = utils$1.findKey(this, header);
 
-          return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+          return !!(
+            key &&
+            this[key] !== undefined &&
+            (!matcher || matchHeaderValue(this, this[key], key, matcher))
+          );
         }
 
         return false;
@@ -34123,7 +34439,7 @@
 
         while (i--) {
           const key = keys[i];
-          if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+          if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
             delete this[key];
             deleted = true;
           }
@@ -34167,7 +34483,9 @@
         const obj = Object.create(null);
 
         utils$1.forEach(this, (value, header) => {
-          value != null && value !== false && (obj[header] = asStrings && utils$1.isArray(value) ? value.join(', ') : value);
+          value != null &&
+            value !== false &&
+            (obj[header] = asStrings && utils$1.isArray(value) ? value.join(', ') : value);
         });
 
         return obj;
@@ -34178,7 +34496,13 @@
       }
 
       toString() {
-        return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n');
+        return Object.entries(this.toJSON())
+          .map(([header, value]) => header + ': ' + value)
+          .join('\n');
+      }
+
+      getSetCookie() {
+        return this.get('set-cookie') || [];
       }
 
       get [Symbol.toStringTag]() {
@@ -34198,9 +34522,12 @@
       }
 
       static accessor(header) {
-        const internals = this[$internals] = (this[$internals] = {
-          accessors: {}
-        });
+        const internals =
+          (this[$internals] =
+          this[$internals] =
+            {
+              accessors: {},
+            });
 
         const accessors = internals.accessors;
         const prototype = this.prototype;
@@ -34220,17 +34547,24 @@
       }
     };
 
-    AxiosHeaders$1.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);
+    AxiosHeaders$1.accessor([
+      'Content-Type',
+      'Content-Length',
+      'Accept',
+      'Accept-Encoding',
+      'User-Agent',
+      'Authorization',
+    ]);
 
     // reserved names hotfix
-    utils$1.reduceDescriptors(AxiosHeaders$1.prototype, ({value}, key) => {
+    utils$1.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key) => {
       let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`
       return {
         get: () => value,
         set(headerValue) {
           this[mapped] = headerValue;
-        }
-      }
+        },
+      };
     });
 
     utils$1.freezeMethods(AxiosHeaders$1);
@@ -34262,24 +34596,22 @@
       return !!(value && value.__CANCEL__);
     }
 
-    /**
-     * A `CanceledError` is an object that is thrown when an operation is canceled.
-     *
-     * @param {string=} message The message.
-     * @param {Object=} config The config.
-     * @param {Object=} request The request.
-     *
-     * @returns {CanceledError} The created error.
-     */
-    function CanceledError$1(message, config, request) {
-      // eslint-disable-next-line no-eq-null,eqeqeq
-      AxiosError$1.call(this, message == null ? 'canceled' : message, AxiosError$1.ERR_CANCELED, config, request);
-      this.name = 'CanceledError';
-    }
-
-    utils$1.inherits(CanceledError$1, AxiosError$1, {
-      __CANCEL__: true
-    });
+    let CanceledError$1 = class CanceledError extends AxiosError$1 {
+      /**
+       * A `CanceledError` is an object that is thrown when an operation is canceled.
+       *
+       * @param {string=} message The message.
+       * @param {Object=} config The config.
+       * @param {Object=} request The request.
+       *
+       * @returns {CanceledError} The created error.
+       */
+      constructor(message, config, request) {
+        super(message == null ? 'canceled' : message, AxiosError$1.ERR_CANCELED, config, request);
+        this.name = 'CanceledError';
+        this.__CANCEL__ = true;
+      }
+    };
 
     /**
      * Resolve or reject a Promise based on response status.
@@ -34295,166 +34627,23 @@
       if (!response.status || !validateStatus || validateStatus(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 = platform.hasStandardBrowserEnv ?
-
-      // Standard browser envs support document.cookie
-      {
-        write(name, value, expires, path, domain, secure) {
-          const cookie = [name + '=' + encodeURIComponent(value)];
-
-          utils$1.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());
-
-          utils$1.isString(path) && cookie.push('path=' + path);
-
-          utils$1.isString(domain) && cookie.push('domain=' + domain);
-
-          secure === true && cookie.push('secure');
-
-          document.cookie = cookie.join('; ');
-        },
-
-        read(name) {
-          const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
-          return (match ? decodeURIComponent(match[3]) : null);
-        },
-
-        remove(name) {
-          this.write(name, '', Date.now() - 86400000);
-        }
-      }
-
-      :
-
-      // Non-standard browser env (web workers, react-native) lack needed support.
-      {
-        write() {},
-        read() {
-          return null;
-        },
-        remove() {}
-      };
-
-    /**
-     * 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
-     */
-    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);
-    }
-
-    /**
-     * 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
-     */
-    function combineURLs(baseURL, relativeURL) {
-      return relativeURL
-        ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
-        : baseURL;
-    }
-
-    /**
-     * Creates a new URL by combining the baseURL with the requestedURL,
-     * only when the requestedURL is not already an absolute URL.
-     * If the requestURL is absolute, this function returns the requestedURL untouched.
-     *
-     * @param {string} baseURL The base URL
-     * @param {string} requestedURL Absolute or relative URL to combine
-     *
-     * @returns {string} The combined full path
-     */
-    function buildFullPath(baseURL, requestedURL) {
-      if (baseURL && !isAbsoluteURL(requestedURL)) {
-        return combineURLs(baseURL, requestedURL);
+        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
+          )
+        );
       }
-      return requestedURL;
     }
 
-    var isURLSameOrigin = platform.hasStandardBrowserEnv ?
-
-    // 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() {
-        const msie = /(msie|trident)/i.test(navigator.userAgent);
-        const urlParsingNode = document.createElement('a');
-        let originURL;
-
-        /**
-        * Parse a URL to discover its components
-        *
-        * @param {String} url The URL to be parsed
-        * @returns {Object}
-        */
-        function resolveURL(url) {
-          let 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) {
-          const parsed = (utils$1.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;
-        };
-      })();
-
     function parseProtocol(url) {
       const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
-      return match && match[1] || '';
+      return (match && match[1]) || '';
     }
 
     /**
@@ -34505,15 +34694,58 @@
 
         const passed = startedAt && now - startedAt;
 
-        return passed ? Math.round(bytesCount * 1000 / passed) : undefined;
+        return passed ? Math.round((bytesCount * 1000) / passed) : undefined;
       };
     }
 
-    function progressEventReducer(listener, isDownloadStream) {
+    /**
+     * Throttle decorator
+     * @param {Function} fn
+     * @param {Number} freq
+     * @return {Function}
+     */
+    function throttle(fn, freq) {
+      let timestamp = 0;
+      let threshold = 1000 / freq;
+      let lastArgs;
+      let timer;
+
+      const invoke = (args, now = Date.now()) => {
+        timestamp = now;
+        lastArgs = null;
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        fn(...args);
+      };
+
+      const throttled = (...args) => {
+        const now = Date.now();
+        const passed = now - timestamp;
+        if (passed >= threshold) {
+          invoke(args, now);
+        } else {
+          lastArgs = args;
+          if (!timer) {
+            timer = setTimeout(() => {
+              timer = null;
+              invoke(lastArgs);
+            }, threshold - passed);
+          }
+        }
+      };
+
+      const flush = () => lastArgs && invoke(lastArgs);
+
+      return [throttled, flush];
+    }
+
+    const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
       let bytesNotified = 0;
       const _speedometer = speedometer(50, 250);
 
-      return e => {
+      return throttle((e) => {
         const loaded = e.loaded;
         const total = e.lengthComputable ? e.total : undefined;
         const progressBytes = loaded - bytesNotified;
@@ -34525,306 +34757,1113 @@
         const data = {
           loaded,
           total,
-          progress: total ? (loaded / total) : undefined,
+          progress: total ? loaded / total : undefined,
           bytes: progressBytes,
           rate: rate ? rate : undefined,
           estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
-          event: e
+          event: e,
+          lengthComputable: total != null,
+          [isDownloadStream ? 'download' : 'upload']: true,
         };
 
-        data[isDownloadStream ? 'download' : 'upload'] = true;
-
         listener(data);
+      }, freq);
+    };
+
+    const progressEventDecorator = (total, throttled) => {
+      const lengthComputable = total != null;
+
+      return [
+        (loaded) =>
+          throttled[0]({
+            lengthComputable,
+            total,
+            loaded,
+          }),
+        throttled[1],
+      ];
+    };
+
+    const asyncDecorator =
+      (fn) =>
+      (...args) =>
+        utils$1.asap(() => fn(...args));
+
+    var isURLSameOrigin = platform.hasStandardBrowserEnv
+      ? ((origin, isMSIE) => (url) => {
+          url = new URL(url, platform.origin);
+
+          return (
+            origin.protocol === url.protocol &&
+            origin.host === url.host &&
+            (isMSIE || origin.port === url.port)
+          );
+        })(
+          new URL(platform.origin),
+          platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
+        )
+      : () => true;
+
+    var cookies = platform.hasStandardBrowserEnv
+      ? // Standard browser envs support document.cookie
+        {
+          write(name, value, expires, path, domain, secure, sameSite) {
+            if (typeof document === 'undefined') return;
+
+            const cookie = [`${name}=${encodeURIComponent(value)}`];
+
+            if (utils$1.isNumber(expires)) {
+              cookie.push(`expires=${new Date(expires).toUTCString()}`);
+            }
+            if (utils$1.isString(path)) {
+              cookie.push(`path=${path}`);
+            }
+            if (utils$1.isString(domain)) {
+              cookie.push(`domain=${domain}`);
+            }
+            if (secure === true) {
+              cookie.push('secure');
+            }
+            if (utils$1.isString(sameSite)) {
+              cookie.push(`SameSite=${sameSite}`);
+            }
+
+            document.cookie = cookie.join('; ');
+          },
+
+          read(name) {
+            if (typeof document === 'undefined') return null;
+            const match = document.cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)'));
+            return match ? decodeURIComponent(match[1]) : null;
+          },
+
+          remove(name) {
+            this.write(name, '', Date.now() - 86400000, '/');
+          },
+        }
+      : // Non-standard browser env (web workers, react-native) lack needed support.
+        {
+          write() {},
+          read() {
+            return null;
+          },
+          remove() {},
+        };
+
+    /**
+     * 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
+     */
+    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.
+      if (typeof url !== 'string') {
+        return false;
+      }
+
+      return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+    }
+
+    /**
+     * 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
+     */
+    function combineURLs(baseURL, relativeURL) {
+      return relativeURL
+        ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+        : baseURL;
+    }
+
+    /**
+     * Creates a new URL by combining the baseURL with the requestedURL,
+     * only when the requestedURL is not already an absolute URL.
+     * If the requestURL is absolute, this function returns the requestedURL untouched.
+     *
+     * @param {string} baseURL The base URL
+     * @param {string} requestedURL Absolute or relative URL to combine
+     *
+     * @returns {string} The combined full path
+     */
+    function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+      let isRelativeUrl = !isAbsoluteURL(requestedURL);
+      if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
+        return combineURLs(baseURL, requestedURL);
+      }
+      return requestedURL;
+    }
+
+    const headersToObject = (thing) => (thing instanceof AxiosHeaders$1 ? { ...thing } : thing);
+
+    /**
+     * Config-specific merge-function which creates a new config-object
+     * by merging two configuration objects together.
+     *
+     * @param {Object} config1
+     * @param {Object} config2
+     *
+     * @returns {Object} New object resulting from merging config2 to config1
+     */
+    function mergeConfig$1(config1, config2) {
+      // eslint-disable-next-line no-param-reassign
+      config2 = config2 || {};
+      const config = {};
+
+      function getMergedValue(target, source, prop, caseless) {
+        if (utils$1.isPlainObject(target) && utils$1.isPlainObject(source)) {
+          return utils$1.merge.call({ caseless }, target, source);
+        } else if (utils$1.isPlainObject(source)) {
+          return utils$1.merge({}, source);
+        } else if (utils$1.isArray(source)) {
+          return source.slice();
+        }
+        return source;
+      }
+
+      function mergeDeepProperties(a, b, prop, caseless) {
+        if (!utils$1.isUndefined(b)) {
+          return getMergedValue(a, b, prop, caseless);
+        } else if (!utils$1.isUndefined(a)) {
+          return getMergedValue(undefined, a, prop, caseless);
+        }
+      }
+
+      // eslint-disable-next-line consistent-return
+      function valueFromConfig2(a, b) {
+        if (!utils$1.isUndefined(b)) {
+          return getMergedValue(undefined, b);
+        }
+      }
+
+      // eslint-disable-next-line consistent-return
+      function defaultToConfig2(a, b) {
+        if (!utils$1.isUndefined(b)) {
+          return getMergedValue(undefined, b);
+        } else if (!utils$1.isUndefined(a)) {
+          return getMergedValue(undefined, a);
+        }
+      }
+
+      // eslint-disable-next-line consistent-return
+      function mergeDirectKeys(a, b, prop) {
+        if (prop in config2) {
+          return getMergedValue(a, b);
+        } else if (prop in config1) {
+          return getMergedValue(undefined, a);
+        }
+      }
+
+      const mergeMap = {
+        url: valueFromConfig2,
+        method: valueFromConfig2,
+        data: valueFromConfig2,
+        baseURL: defaultToConfig2,
+        transformRequest: defaultToConfig2,
+        transformResponse: defaultToConfig2,
+        paramsSerializer: defaultToConfig2,
+        timeout: defaultToConfig2,
+        timeoutMessage: defaultToConfig2,
+        withCredentials: defaultToConfig2,
+        withXSRFToken: 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,
+        headers: (a, b, prop) =>
+          mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true),
       };
+
+      utils$1.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
+        if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') return;
+        const merge = utils$1.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
+        const configValue = merge(config1[prop], config2[prop], prop);
+        (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
+      });
+
+      return config;
     }
 
-    const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
+    var resolveConfig = (config) => {
+      const newConfig = mergeConfig$1({}, config);
 
-    var xhrAdapter = isXHRAdapterSupported && function (config) {
-      return new Promise(function dispatchXhrRequest(resolve, reject) {
-        let requestData = config.data;
-        const requestHeaders = AxiosHeaders$1.from(config.headers).normalize();
-        let {responseType, withXSRFToken} = config;
-        let onCanceled;
-        function done() {
-          if (config.cancelToken) {
-            config.cancelToken.unsubscribe(onCanceled);
-          }
+      let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
 
-          if (config.signal) {
-            config.signal.removeEventListener('abort', onCanceled);
-          }
+      newConfig.headers = headers = AxiosHeaders$1.from(headers);
+
+      newConfig.url = buildURL(
+        buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls),
+        config.params,
+        config.paramsSerializer
+      );
+
+      // HTTP basic authentication
+      if (auth) {
+        headers.set(
+          'Authorization',
+          'Basic ' +
+            btoa(
+              (auth.username || '') +
+                ':' +
+                (auth.password ? unescape(encodeURIComponent(auth.password)) : '')
+            )
+        );
+      }
+
+      if (utils$1.isFormData(data)) {
+        if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
+          headers.setContentType(undefined); // browser handles it
+        } else if (utils$1.isFunction(data.getHeaders)) {
+          // Node.js FormData (like form-data package)
+          const formHeaders = data.getHeaders();
+          // Only set safe headers to avoid overwriting security headers
+          const allowedHeaders = ['content-type', 'content-length'];
+          Object.entries(formHeaders).forEach(([key, val]) => {
+            if (allowedHeaders.includes(key.toLowerCase())) {
+              headers.set(key, val);
+            }
+          });
         }
+      }
+
+      // 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.
 
-        let contentType;
+      if (platform.hasStandardBrowserEnv) {
+        withXSRFToken && utils$1.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
 
-        if (utils$1.isFormData(requestData)) {
-          if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
-            requestHeaders.setContentType(false); // Let the browser set it
-          } else if ((contentType = requestHeaders.getContentType()) !== false) {
-            // fix semicolon duplication issue for ReactNative FormData implementation
-            const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];
-            requestHeaders.setContentType([type || 'multipart/form-data', ...tokens].join('; '));
+        if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(newConfig.url))) {
+          // Add xsrf header
+          const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);
+
+          if (xsrfValue) {
+            headers.set(xsrfHeaderName, xsrfValue);
           }
         }
+      }
 
-        let request = new XMLHttpRequest();
+      return newConfig;
+    };
 
-        // HTTP basic authentication
-        if (config.auth) {
-          const username = config.auth.username || '';
-          const password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
-          requestHeaders.set('Authorization', 'Basic ' + btoa(username + ':' + password));
-        }
+    const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
 
-        const fullPath = buildFullPath(config.baseURL, config.url);
+    var xhrAdapter = isXHRAdapterSupported &&
+      function (config) {
+        return new Promise(function dispatchXhrRequest(resolve, reject) {
+          const _config = resolveConfig(config);
+          let requestData = _config.data;
+          const requestHeaders = AxiosHeaders$1.from(_config.headers).normalize();
+          let { responseType, onUploadProgress, onDownloadProgress } = _config;
+          let onCanceled;
+          let uploadThrottled, downloadThrottled;
+          let flushUpload, flushDownload;
 
-        request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+          function done() {
+            flushUpload && flushUpload(); // flush events
+            flushDownload && flushDownload(); // flush events
 
-        // Set the request timeout in MS
-        request.timeout = config.timeout;
+            _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
 
-        function onloadend() {
-          if (!request) {
-            return;
+            _config.signal && _config.signal.removeEventListener('abort', onCanceled);
           }
-          // Prepare the response
-          const responseHeaders = AxiosHeaders$1.from(
-            'getAllResponseHeaders' in request && request.getAllResponseHeaders()
-          );
-          const responseData = !responseType || responseType === 'text' || responseType === 'json' ?
-            request.responseText : request.response;
-          const response = {
-            data: responseData,
-            status: request.status,
-            statusText: request.statusText,
-            headers: responseHeaders,
-            config,
-            request
-          };
 
-          settle(function _resolve(value) {
-            resolve(value);
-            done();
-          }, function _reject(err) {
-            reject(err);
-            done();
-          }, response);
+          let request = new XMLHttpRequest();
 
-          // Clean up request
-          request = null;
-        }
+          request.open(_config.method.toUpperCase(), _config.url, true);
 
-        if ('onloadend' in request) {
-          // Use onloadend if available
-          request.onloadend = onloadend;
-        } else {
-          // Listen for ready state to emulate onloadend
-          request.onreadystatechange = function handleLoad() {
-            if (!request || request.readyState !== 4) {
+          // Set the request timeout in MS
+          request.timeout = _config.timeout;
+
+          function onloadend() {
+            if (!request) {
               return;
             }
+            // Prepare the response
+            const responseHeaders = AxiosHeaders$1.from(
+              'getAllResponseHeaders' in request && request.getAllResponseHeaders()
+            );
+            const responseData =
+              !responseType || responseType === 'text' || responseType === 'json'
+                ? request.responseText
+                : request.response;
+            const response = {
+              data: responseData,
+              status: request.status,
+              statusText: request.statusText,
+              headers: responseHeaders,
+              config,
+              request,
+            };
+
+            settle(
+              function _resolve(value) {
+                resolve(value);
+                done();
+              },
+              function _reject(err) {
+                reject(err);
+                done();
+              },
+              response
+            );
+
+            // Clean up request
+            request = null;
+          }
 
-            // 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)) {
+          if ('onloadend' in request) {
+            // Use onloadend if available
+            request.onloadend = onloadend;
+          } else {
+            // Listen for ready state to emulate onloadend
+            request.onreadystatechange = function handleLoad() {
+              if (!request || request.readyState !== 4) {
+                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;
+              }
+              // readystate handler is calling before onerror or ontimeout handlers,
+              // so we should call onloadend on the next 'tick'
+              setTimeout(onloadend);
+            };
+          }
+
+          // Handle browser request cancellation (as opposed to a manual cancellation)
+          request.onabort = function handleAbort() {
+            if (!request) {
               return;
             }
-            // readystate handler is calling before onerror or ontimeout handlers,
-            // so we should call onloadend on the next 'tick'
-            setTimeout(onloadend);
+
+            reject(new AxiosError$1('Request aborted', AxiosError$1.ECONNABORTED, config, request));
+
+            // Clean up request
+            request = null;
+          };
+
+          // Handle low level network errors
+          request.onerror = function handleError(event) {
+            // Browsers deliver a ProgressEvent in XHR onerror
+            // (message may be empty; when present, surface it)
+            // See https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/error_event
+            const msg = event && event.message ? event.message : 'Network Error';
+            const err = new AxiosError$1(msg, AxiosError$1.ERR_NETWORK, config, request);
+            // attach the underlying event for consumers who want details
+            err.event = event || null;
+            reject(err);
+            request = null;
           };
-        }
 
-        // Handle browser request cancellation (as opposed to a manual cancellation)
-        request.onabort = function handleAbort() {
-          if (!request) {
+          // Handle timeout
+          request.ontimeout = function handleTimeout() {
+            let timeoutErrorMessage = _config.timeout
+              ? 'timeout of ' + _config.timeout + 'ms exceeded'
+              : 'timeout exceeded';
+            const transitional = _config.transitional || transitionalDefaults;
+            if (_config.timeoutErrorMessage) {
+              timeoutErrorMessage = _config.timeoutErrorMessage;
+            }
+            reject(
+              new AxiosError$1(
+                timeoutErrorMessage,
+                transitional.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
+                config,
+                request
+              )
+            );
+
+            // Clean up request
+            request = null;
+          };
+
+          // Remove Content-Type if data is undefined
+          requestData === undefined && requestHeaders.setContentType(null);
+
+          // Add headers to the request
+          if ('setRequestHeader' in request) {
+            utils$1.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+              request.setRequestHeader(key, val);
+            });
+          }
+
+          // Add withCredentials to request if needed
+          if (!utils$1.isUndefined(_config.withCredentials)) {
+            request.withCredentials = !!_config.withCredentials;
+          }
+
+          // Add responseType to request if needed
+          if (responseType && responseType !== 'json') {
+            request.responseType = _config.responseType;
+          }
+
+          // Handle progress if needed
+          if (onDownloadProgress) {
+            [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
+            request.addEventListener('progress', downloadThrottled);
+          }
+
+          // Not all browsers support upload events
+          if (onUploadProgress && request.upload) {
+            [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
+
+            request.upload.addEventListener('progress', uploadThrottled);
+
+            request.upload.addEventListener('loadend', flushUpload);
+          }
+
+          if (_config.cancelToken || _config.signal) {
+            // Handle cancellation
+            // eslint-disable-next-line func-names
+            onCanceled = (cancel) => {
+              if (!request) {
+                return;
+              }
+              reject(!cancel || cancel.type ? new CanceledError$1(null, config, request) : cancel);
+              request.abort();
+              request = null;
+            };
+
+            _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
+            if (_config.signal) {
+              _config.signal.aborted
+                ? onCanceled()
+                : _config.signal.addEventListener('abort', onCanceled);
+            }
+          }
+
+          const protocol = parseProtocol(_config.url);
+
+          if (protocol && platform.protocols.indexOf(protocol) === -1) {
+            reject(
+              new AxiosError$1(
+                'Unsupported protocol ' + protocol + ':',
+                AxiosError$1.ERR_BAD_REQUEST,
+                config
+              )
+            );
             return;
           }
 
-          reject(new AxiosError$1('Request aborted', AxiosError$1.ECONNABORTED, config, request));
+          // Send the request
+          request.send(requestData || null);
+        });
+      };
 
-          // Clean up request
-          request = null;
-        };
+    const composeSignals = (signals, timeout) => {
+      const { length } = (signals = signals ? signals.filter(Boolean) : []);
+
+      if (timeout || length) {
+        let controller = new AbortController();
 
-        // 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(new AxiosError$1('Network Error', AxiosError$1.ERR_NETWORK, config, request));
+        let aborted;
 
-          // Clean up request
-          request = null;
+        const onabort = function (reason) {
+          if (!aborted) {
+            aborted = true;
+            unsubscribe();
+            const err = reason instanceof Error ? reason : this.reason;
+            controller.abort(
+              err instanceof AxiosError$1
+                ? err
+                : new CanceledError$1(err instanceof Error ? err.message : err)
+            );
+          }
         };
 
-        // Handle timeout
-        request.ontimeout = function handleTimeout() {
-          let timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
-          const transitional = config.transitional || transitionalDefaults;
-          if (config.timeoutErrorMessage) {
-            timeoutErrorMessage = config.timeoutErrorMessage;
+        let timer =
+          timeout &&
+          setTimeout(() => {
+            timer = null;
+            onabort(new AxiosError$1(`timeout of ${timeout}ms exceeded`, AxiosError$1.ETIMEDOUT));
+          }, timeout);
+
+        const unsubscribe = () => {
+          if (signals) {
+            timer && clearTimeout(timer);
+            timer = null;
+            signals.forEach((signal) => {
+              signal.unsubscribe
+                ? signal.unsubscribe(onabort)
+                : signal.removeEventListener('abort', onabort);
+            });
+            signals = null;
           }
-          reject(new AxiosError$1(
-            timeoutErrorMessage,
-            transitional.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
-            config,
-            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(platform.hasStandardBrowserEnv) {
-          withXSRFToken && utils$1.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(config));
+        signals.forEach((signal) => signal.addEventListener('abort', onabort));
 
-          if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(fullPath))) {
-            // Add xsrf header
-            const xsrfValue = config.xsrfHeaderName && config.xsrfCookieName && cookies.read(config.xsrfCookieName);
+        const { signal } = controller;
 
-            if (xsrfValue) {
-              requestHeaders.set(config.xsrfHeaderName, xsrfValue);
-            }
+        signal.unsubscribe = () => utils$1.asap(unsubscribe);
+
+        return signal;
+      }
+    };
+
+    const streamChunk = function* (chunk, chunkSize) {
+      let len = chunk.byteLength;
+
+      if (len < chunkSize) {
+        yield chunk;
+        return;
+      }
+
+      let pos = 0;
+      let end;
+
+      while (pos < len) {
+        end = pos + chunkSize;
+        yield chunk.slice(pos, end);
+        pos = end;
+      }
+    };
+
+    const readBytes = async function* (iterable, chunkSize) {
+      for await (const chunk of readStream(iterable)) {
+        yield* streamChunk(chunk, chunkSize);
+      }
+    };
+
+    const readStream = async function* (stream) {
+      if (stream[Symbol.asyncIterator]) {
+        yield* stream;
+        return;
+      }
+
+      const reader = stream.getReader();
+      try {
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
           }
+          yield value;
         }
+      } finally {
+        await reader.cancel();
+      }
+    };
+
+    const trackStream = (stream, chunkSize, onProgress, onFinish) => {
+      const iterator = readBytes(stream, chunkSize);
+
+      let bytes = 0;
+      let done;
+      let _onFinish = (e) => {
+        if (!done) {
+          done = true;
+          onFinish && onFinish(e);
+        }
+      };
+
+      return new ReadableStream(
+        {
+          async pull(controller) {
+            try {
+              const { done, value } = await iterator.next();
+
+              if (done) {
+                _onFinish();
+                controller.close();
+                return;
+              }
+
+              let len = value.byteLength;
+              if (onProgress) {
+                let loadedBytes = (bytes += len);
+                onProgress(loadedBytes);
+              }
+              controller.enqueue(new Uint8Array(value));
+            } catch (err) {
+              _onFinish(err);
+              throw err;
+            }
+          },
+          cancel(reason) {
+            _onFinish(reason);
+            return iterator.return();
+          },
+        },
+        {
+          highWaterMark: 2,
+        }
+      );
+    };
+
+    const DEFAULT_CHUNK_SIZE = 64 * 1024;
+
+    const { isFunction: isFunction$1 } = utils$1;
+
+    const globalFetchAPI = (({ Request, Response }) => ({
+      Request,
+      Response,
+    }))(utils$1.global);
+
+    const { ReadableStream: ReadableStream$1, TextEncoder: TextEncoder$1 } = utils$1.global;
+
+    const test = (fn, ...args) => {
+      try {
+        return !!fn(...args);
+      } catch (e) {
+        return false;
+      }
+    };
+
+    const factory = (env) => {
+      env = utils$1.merge.call(
+        {
+          skipUndefined: true,
+        },
+        globalFetchAPI,
+        env
+      );
+
+      const { fetch: envFetch, Request, Response } = env;
+      const isFetchSupported = envFetch ? isFunction$1(envFetch) : typeof fetch === 'function';
+      const isRequestSupported = isFunction$1(Request);
+      const isResponseSupported = isFunction$1(Response);
+
+      if (!isFetchSupported) {
+        return false;
+      }
+
+      const isReadableStreamSupported = isFetchSupported && isFunction$1(ReadableStream$1);
+
+      const encodeText =
+        isFetchSupported &&
+        (typeof TextEncoder$1 === 'function'
+          ? (
+              (encoder) => (str) =>
+                encoder.encode(str)
+            )(new TextEncoder$1())
+          : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
+
+      const supportsRequestStream =
+        isRequestSupported &&
+        isReadableStreamSupported &&
+        test(() => {
+          let duplexAccessed = false;
+
+          const body = new ReadableStream$1();
+
+          const hasContentType = new Request(platform.origin, {
+            body,
+            method: 'POST',
+            get duplex() {
+              duplexAccessed = true;
+              return 'half';
+            },
+          }).headers.has('Content-Type');
+
+          body.cancel();
+
+          return duplexAccessed && !hasContentType;
+        });
+
+      const supportsResponseStream =
+        isResponseSupported &&
+        isReadableStreamSupported &&
+        test(() => utils$1.isReadableStream(new Response('').body));
 
-        // Remove Content-Type if data is undefined
-        requestData === undefined && requestHeaders.setContentType(null);
+      const resolvers = {
+        stream: supportsResponseStream && ((res) => res.body),
+      };
+
+      isFetchSupported &&
+        (() => {
+          ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach((type) => {
+            !resolvers[type] &&
+              (resolvers[type] = (res, config) => {
+                let method = res && res[type];
+
+                if (method) {
+                  return method.call(res);
+                }
 
-        // Add headers to the request
-        if ('setRequestHeader' in request) {
-          utils$1.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
-            request.setRequestHeader(key, val);
+                throw new AxiosError$1(
+                  `Response type '${type}' is not supported`,
+                  AxiosError$1.ERR_NOT_SUPPORT,
+                  config
+                );
+              });
           });
+        })();
+
+      const getBodyLength = async (body) => {
+        if (body == null) {
+          return 0;
         }
 
-        // Add withCredentials to request if needed
-        if (!utils$1.isUndefined(config.withCredentials)) {
-          request.withCredentials = !!config.withCredentials;
+        if (utils$1.isBlob(body)) {
+          return body.size;
         }
 
-        // Add responseType to request if needed
-        if (responseType && responseType !== 'json') {
-          request.responseType = config.responseType;
+        if (utils$1.isSpecCompliantForm(body)) {
+          const _request = new Request(platform.origin, {
+            method: 'POST',
+            body,
+          });
+          return (await _request.arrayBuffer()).byteLength;
         }
 
-        // Handle progress if needed
-        if (typeof config.onDownloadProgress === 'function') {
-          request.addEventListener('progress', progressEventReducer(config.onDownloadProgress, true));
+        if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
+          return body.byteLength;
         }
 
-        // Not all browsers support upload events
-        if (typeof config.onUploadProgress === 'function' && request.upload) {
-          request.upload.addEventListener('progress', progressEventReducer(config.onUploadProgress));
+        if (utils$1.isURLSearchParams(body)) {
+          body = body + '';
         }
 
-        if (config.cancelToken || config.signal) {
-          // Handle cancellation
-          // eslint-disable-next-line func-names
-          onCanceled = cancel => {
-            if (!request) {
-              return;
+        if (utils$1.isString(body)) {
+          return (await encodeText(body)).byteLength;
+        }
+      };
+
+      const resolveBodyLength = async (headers, body) => {
+        const length = utils$1.toFiniteNumber(headers.getContentLength());
+
+        return length == null ? getBodyLength(body) : length;
+      };
+
+      return async (config) => {
+        let {
+          url,
+          method,
+          data,
+          signal,
+          cancelToken,
+          timeout,
+          onDownloadProgress,
+          onUploadProgress,
+          responseType,
+          headers,
+          withCredentials = 'same-origin',
+          fetchOptions,
+        } = resolveConfig(config);
+
+        let _fetch = envFetch || fetch;
+
+        responseType = responseType ? (responseType + '').toLowerCase() : 'text';
+
+        let composedSignal = composeSignals(
+          [signal, cancelToken && cancelToken.toAbortSignal()],
+          timeout
+        );
+
+        let request = null;
+
+        const unsubscribe =
+          composedSignal &&
+          composedSignal.unsubscribe &&
+          (() => {
+            composedSignal.unsubscribe();
+          });
+
+        let requestContentLength;
+
+        try {
+          if (
+            onUploadProgress &&
+            supportsRequestStream &&
+            method !== 'get' &&
+            method !== 'head' &&
+            (requestContentLength = await resolveBodyLength(headers, data)) !== 0
+          ) {
+            let _request = new Request(url, {
+              method: 'POST',
+              body: data,
+              duplex: 'half',
+            });
+
+            let contentTypeHeader;
+
+            if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
+              headers.setContentType(contentTypeHeader);
             }
-            reject(!cancel || cancel.type ? new CanceledError$1(null, config, request) : cancel);
-            request.abort();
-            request = null;
+
+            if (_request.body) {
+              const [onProgress, flush] = progressEventDecorator(
+                requestContentLength,
+                progressEventReducer(asyncDecorator(onUploadProgress))
+              );
+
+              data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+            }
+          }
+
+          if (!utils$1.isString(withCredentials)) {
+            withCredentials = withCredentials ? 'include' : 'omit';
+          }
+
+          // Cloudflare Workers throws when credentials are defined
+          // see https://github.com/cloudflare/workerd/issues/902
+          const isCredentialsSupported = isRequestSupported && 'credentials' in Request.prototype;
+
+          const resolvedOptions = {
+            ...fetchOptions,
+            signal: composedSignal,
+            method: method.toUpperCase(),
+            headers: headers.normalize().toJSON(),
+            body: data,
+            duplex: 'half',
+            credentials: isCredentialsSupported ? withCredentials : undefined,
           };
 
-          config.cancelToken && config.cancelToken.subscribe(onCanceled);
-          if (config.signal) {
-            config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
+          request = isRequestSupported && new Request(url, resolvedOptions);
+
+          let response = await (isRequestSupported
+            ? _fetch(request, fetchOptions)
+            : _fetch(url, resolvedOptions));
+
+          const isStreamResponse =
+            supportsResponseStream && (responseType === 'stream' || responseType === 'response');
+
+          if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
+            const options = {};
+
+            ['status', 'statusText', 'headers'].forEach((prop) => {
+              options[prop] = response[prop];
+            });
+
+            const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
+
+            const [onProgress, flush] =
+              (onDownloadProgress &&
+                progressEventDecorator(
+                  responseContentLength,
+                  progressEventReducer(asyncDecorator(onDownloadProgress), true)
+                )) ||
+              [];
+
+            response = new Response(
+              trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+                flush && flush();
+                unsubscribe && unsubscribe();
+              }),
+              options
+            );
           }
-        }
 
-        const protocol = parseProtocol(fullPath);
+          responseType = responseType || 'text';
 
-        if (protocol && platform.protocols.indexOf(protocol) === -1) {
-          reject(new AxiosError$1('Unsupported protocol ' + protocol + ':', AxiosError$1.ERR_BAD_REQUEST, config));
-          return;
+          let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](
+            response,
+            config
+          );
+
+          !isStreamResponse && unsubscribe && unsubscribe();
+
+          return await new Promise((resolve, reject) => {
+            settle(resolve, reject, {
+              data: responseData,
+              headers: AxiosHeaders$1.from(response.headers),
+              status: response.status,
+              statusText: response.statusText,
+              config,
+              request,
+            });
+          });
+        } catch (err) {
+          unsubscribe && unsubscribe();
+
+          if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
+            throw Object.assign(
+              new AxiosError$1(
+                'Network Error',
+                AxiosError$1.ERR_NETWORK,
+                config,
+                request,
+                err && err.response
+              ),
+              {
+                cause: err.cause || err,
+              }
+            );
+          }
+
+          throw AxiosError$1.from(err, err && err.code, config, request, err && err.response);
         }
+      };
+    };
 
+    const seedCache = new Map();
 
-        // Send the request
-        request.send(requestData || null);
-      });
+    const getFetch = (config) => {
+      let env = (config && config.env) || {};
+      const { fetch, Request, Response } = env;
+      const seeds = [Request, Response, fetch];
+
+      let len = seeds.length,
+        i = len,
+        seed,
+        target,
+        map = seedCache;
+
+      while (i--) {
+        seed = seeds[i];
+        target = map.get(seed);
+
+        target === undefined && map.set(seed, (target = i ? new Map() : factory(env)));
+
+        map = target;
+      }
+
+      return target;
     };
 
+    getFetch();
+
+    /**
+     * Known adapters mapping.
+     * Provides environment-specific adapters for Axios:
+     * - `http` for Node.js
+     * - `xhr` for browsers
+     * - `fetch` for fetch API-based requests
+     *
+     * @type {Object<string, Function|Object>}
+     */
     const knownAdapters = {
       http: httpAdapter,
-      xhr: xhrAdapter
+      xhr: xhrAdapter,
+      fetch: {
+        get: getFetch,
+      },
     };
 
+    // Assign adapter names for easier debugging and identification
     utils$1.forEach(knownAdapters, (fn, value) => {
       if (fn) {
         try {
-          Object.defineProperty(fn, 'name', {value});
+          Object.defineProperty(fn, 'name', { value });
         } catch (e) {
           // eslint-disable-next-line no-empty
         }
-        Object.defineProperty(fn, 'adapterName', {value});
+        Object.defineProperty(fn, 'adapterName', { value });
       }
     });
 
+    /**
+     * Render a rejection reason string for unknown or unsupported adapters
+     *
+     * @param {string} reason
+     * @returns {string}
+     */
     const renderReason = (reason) => `- ${reason}`;
 
-    const isResolvedHandle = (adapter) => utils$1.isFunction(adapter) || adapter === null || adapter === false;
+    /**
+     * Check if the adapter is resolved (function, null, or false)
+     *
+     * @param {Function|null|false} adapter
+     * @returns {boolean}
+     */
+    const isResolvedHandle = (adapter) =>
+      utils$1.isFunction(adapter) || adapter === null || adapter === false;
 
-    var adapters = {
-      getAdapter: (adapters) => {
-        adapters = utils$1.isArray(adapters) ? adapters : [adapters];
+    /**
+     * Get the first suitable adapter from the provided list.
+     * Tries each adapter in order until a supported one is found.
+     * Throws an AxiosError if no adapter is suitable.
+     *
+     * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.
+     * @param {Object} config - Axios request configuration
+     * @throws {AxiosError} If no suitable adapter is available
+     * @returns {Function} The resolved adapter function
+     */
+    function getAdapter$1(adapters, config) {
+      adapters = utils$1.isArray(adapters) ? adapters : [adapters];
 
-        const {length} = adapters;
-        let nameOrAdapter;
-        let adapter;
+      const { length } = adapters;
+      let nameOrAdapter;
+      let adapter;
 
-        const rejectedReasons = {};
+      const rejectedReasons = {};
 
-        for (let i = 0; i < length; i++) {
-          nameOrAdapter = adapters[i];
-          let id;
+      for (let i = 0; i < length; i++) {
+        nameOrAdapter = adapters[i];
+        let id;
 
-          adapter = nameOrAdapter;
+        adapter = nameOrAdapter;
 
-          if (!isResolvedHandle(nameOrAdapter)) {
-            adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+        if (!isResolvedHandle(nameOrAdapter)) {
+          adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
 
-            if (adapter === undefined) {
-              throw new AxiosError$1(`Unknown adapter '${id}'`);
-            }
-          }
-
-          if (adapter) {
-            break;
+          if (adapter === undefined) {
+            throw new AxiosError$1(`Unknown adapter '${id}'`);
           }
+        }
 
-          rejectedReasons[id || '#' + i] = adapter;
+        if (adapter && (utils$1.isFunction(adapter) || (adapter = adapter.get(config)))) {
+          break;
         }
 
-        if (!adapter) {
+        rejectedReasons[id || '#' + i] = adapter;
+      }
 
-          const reasons = Object.entries(rejectedReasons)
-            .map(([id, state]) => `adapter ${id} ` +
-              (state === false ? 'is not supported by the environment' : 'is not available in the build')
-            );
+      if (!adapter) {
+        const reasons = Object.entries(rejectedReasons).map(
+          ([id, state]) =>
+            `adapter ${id} ` +
+            (state === false ? 'is not supported by the environment' : 'is not available in the build')
+        );
 
-          let s = length ?
-            (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
-            'as no adapter specified';
+        let s = length
+          ? reasons.length > 1
+            ? 'since :\n' + reasons.map(renderReason).join('\n')
+            : ' ' + renderReason(reasons[0])
+          : 'as no adapter specified';
 
-          throw new AxiosError$1(
-            `There is no suitable adapter to dispatch the request ` + s,
-            'ERR_NOT_SUPPORT'
-          );
-        }
+        throw new AxiosError$1(
+          `There is no suitable adapter to dispatch the request ` + s,
+          'ERR_NOT_SUPPORT'
+        );
+      }
 
-        return adapter;
-      },
-      adapters: knownAdapters
+      return adapter;
+    }
+
+    /**
+     * Exports Axios adapters and utility to resolve an adapter
+     */
+    var adapters = {
+      /**
+       * Resolve an adapter from a list of adapter names or functions.
+       * @type {Function}
+       */
+      getAdapter: getAdapter$1,
+
+      /**
+       * Exposes all known adapters
+       * @type {Object<string, Function|Object>}
+       */
+      adapters: knownAdapters,
     };
 
     /**
@@ -34857,152 +35896,46 @@
       config.headers = AxiosHeaders$1.from(config.headers);
 
       // Transform request data
-      config.data = transformData.call(
-        config,
-        config.transformRequest
-      );
+      config.data = transformData.call(config, config.transformRequest);
 
       if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {
         config.headers.setContentType('application/x-www-form-urlencoded', false);
       }
 
-      const adapter = adapters.getAdapter(config.adapter || defaults.adapter);
-
-      return adapter(config).then(function onAdapterResolution(response) {
-        throwIfCancellationRequested(config);
-
-        // Transform response data
-        response.data = transformData.call(
-          config,
-          config.transformResponse,
-          response
-        );
+      const adapter = adapters.getAdapter(config.adapter || defaults.adapter, config);
 
-        response.headers = AxiosHeaders$1.from(response.headers);
-
-        return response;
-      }, function onAdapterRejection(reason) {
-        if (!isCancel$1(reason)) {
+      return adapter(config).then(
+        function onAdapterResolution(response) {
           throwIfCancellationRequested(config);
 
           // Transform response data
-          if (reason && reason.response) {
-            reason.response.data = transformData.call(
-              config,
-              config.transformResponse,
-              reason.response
-            );
-            reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
-          }
-        }
+          response.data = transformData.call(config, config.transformResponse, response);
 
-        return Promise.reject(reason);
-      });
-    }
-
-    const headersToObject = (thing) => thing instanceof AxiosHeaders$1 ? thing.toJSON() : thing;
+          response.headers = AxiosHeaders$1.from(response.headers);
 
-    /**
-     * Config-specific merge-function which creates a new config-object
-     * by merging two configuration objects together.
-     *
-     * @param {Object} config1
-     * @param {Object} config2
-     *
-     * @returns {Object} New object resulting from merging config2 to config1
-     */
-    function mergeConfig$1(config1, config2) {
-      // eslint-disable-next-line no-param-reassign
-      config2 = config2 || {};
-      const config = {};
-
-      function getMergedValue(target, source, caseless) {
-        if (utils$1.isPlainObject(target) && utils$1.isPlainObject(source)) {
-          return utils$1.merge.call({caseless}, target, source);
-        } else if (utils$1.isPlainObject(source)) {
-          return utils$1.merge({}, source);
-        } else if (utils$1.isArray(source)) {
-          return source.slice();
-        }
-        return source;
-      }
-
-      // eslint-disable-next-line consistent-return
-      function mergeDeepProperties(a, b, caseless) {
-        if (!utils$1.isUndefined(b)) {
-          return getMergedValue(a, b, caseless);
-        } else if (!utils$1.isUndefined(a)) {
-          return getMergedValue(undefined, a, caseless);
-        }
-      }
-
-      // eslint-disable-next-line consistent-return
-      function valueFromConfig2(a, b) {
-        if (!utils$1.isUndefined(b)) {
-          return getMergedValue(undefined, b);
-        }
-      }
-
-      // eslint-disable-next-line consistent-return
-      function defaultToConfig2(a, b) {
-        if (!utils$1.isUndefined(b)) {
-          return getMergedValue(undefined, b);
-        } else if (!utils$1.isUndefined(a)) {
-          return getMergedValue(undefined, a);
-        }
-      }
+          return response;
+        },
+        function onAdapterRejection(reason) {
+          if (!isCancel$1(reason)) {
+            throwIfCancellationRequested(config);
+
+            // Transform response data
+            if (reason && reason.response) {
+              reason.response.data = transformData.call(
+                config,
+                config.transformResponse,
+                reason.response
+              );
+              reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
+            }
+          }
 
-      // eslint-disable-next-line consistent-return
-      function mergeDirectKeys(a, b, prop) {
-        if (prop in config2) {
-          return getMergedValue(a, b);
-        } else if (prop in config1) {
-          return getMergedValue(undefined, a);
+          return Promise.reject(reason);
         }
-      }
-
-      const mergeMap = {
-        url: valueFromConfig2,
-        method: valueFromConfig2,
-        data: valueFromConfig2,
-        baseURL: defaultToConfig2,
-        transformRequest: defaultToConfig2,
-        transformResponse: defaultToConfig2,
-        paramsSerializer: defaultToConfig2,
-        timeout: defaultToConfig2,
-        timeoutMessage: defaultToConfig2,
-        withCredentials: defaultToConfig2,
-        withXSRFToken: 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,
-        headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)
-      };
-
-      utils$1.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
-        const merge = mergeMap[prop] || mergeDeepProperties;
-        const configValue = merge(config1[prop], config2[prop], prop);
-        (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
-      });
-
-      return config;
+      );
     }
 
-    const VERSION$1 = "1.6.2";
+    const VERSION$1 = "1.15.0";
 
     const validators$1 = {};
 
@@ -35026,7 +35959,15 @@
      */
     validators$1.transitional = function transitional(validator, version, message) {
       function formatMessage(opt, desc) {
-        return '[Axios v' + VERSION$1 + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
+        return (
+          '[Axios v' +
+          VERSION$1 +
+          "] Transitional option '" +
+          opt +
+          "'" +
+          desc +
+          (message ? '. ' + message : '')
+        );
       }
 
       // eslint-disable-next-line func-names
@@ -35053,6 +35994,14 @@
       };
     };
 
+    validators$1.spelling = function spelling(correctSpelling) {
+      return (value, opt) => {
+        // eslint-disable-next-line no-console
+        console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
+        return true;
+      };
+    };
+
     /**
      * Assert object's properties type
      *
@@ -35076,7 +36025,10 @@
           const value = options[opt];
           const result = value === undefined || validator(value, opt, options);
           if (result !== true) {
-            throw new AxiosError$1('option ' + opt + ' must be ' + result, AxiosError$1.ERR_BAD_OPTION_VALUE);
+            throw new AxiosError$1(
+              'option ' + opt + ' must be ' + result,
+              AxiosError$1.ERR_BAD_OPTION_VALUE
+            );
           }
           continue;
         }
@@ -35088,7 +36040,7 @@
 
     var validator = {
       assertOptions,
-      validators: validators$1
+      validators: validators$1,
     };
 
     const validators = validator.validators;
@@ -35102,10 +36054,10 @@
      */
     let Axios$1 = class Axios {
       constructor(instanceConfig) {
-        this.defaults = instanceConfig;
+        this.defaults = instanceConfig || {};
         this.interceptors = {
           request: new InterceptorManager(),
-          response: new InterceptorManager()
+          response: new InterceptorManager(),
         };
       }
 
@@ -35117,7 +36069,50 @@
        *
        * @returns {Promise} The Promise to be fulfilled
        */
-      request(configOrUrl, config) {
+      async request(configOrUrl, config) {
+        try {
+          return await this._request(configOrUrl, config);
+        } catch (err) {
+          if (err instanceof Error) {
+            let dummy = {};
+
+            Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());
+
+            // slice off the Error: ... line
+            const stack = (() => {
+              if (!dummy.stack) {
+                return '';
+              }
+
+              const firstNewlineIndex = dummy.stack.indexOf('\n');
+
+              return firstNewlineIndex === -1 ? '' : dummy.stack.slice(firstNewlineIndex + 1);
+            })();
+            try {
+              if (!err.stack) {
+                err.stack = stack;
+                // match without the 2 top stack lines
+              } else if (stack) {
+                const firstNewlineIndex = stack.indexOf('\n');
+                const secondNewlineIndex =
+                  firstNewlineIndex === -1 ? -1 : stack.indexOf('\n', firstNewlineIndex + 1);
+                const stackWithoutTwoTopLines =
+                  secondNewlineIndex === -1 ? '' : stack.slice(secondNewlineIndex + 1);
+
+                if (!String(err.stack).endsWith(stackWithoutTwoTopLines)) {
+                  err.stack += '\n' + stack;
+                }
+              }
+            } catch (e) {
+              // ignore the case where "stack" is an un-writable property
+            }
+          }
+
+          throw err;
+        }
+      }
+
+      _request(configOrUrl, config) {
         /*eslint no-param-reassign:0*/
         // Allow for axios('example/url'[, config]) a la fetch API
         if (typeof configOrUrl === 'string') {
@@ -35129,44 +36124,64 @@
 
         config = mergeConfig$1(this.defaults, config);
 
-        const {transitional, paramsSerializer, headers} = config;
+        const { transitional, paramsSerializer, headers } = config;
 
         if (transitional !== undefined) {
-          validator.assertOptions(transitional, {
-            silentJSONParsing: validators.transitional(validators.boolean),
-            forcedJSONParsing: validators.transitional(validators.boolean),
-            clarifyTimeoutError: validators.transitional(validators.boolean)
-          }, false);
+          validator.assertOptions(
+            transitional,
+            {
+              silentJSONParsing: validators.transitional(validators.boolean),
+              forcedJSONParsing: validators.transitional(validators.boolean),
+              clarifyTimeoutError: validators.transitional(validators.boolean),
+              legacyInterceptorReqResOrdering: validators.transitional(validators.boolean),
+            },
+            false
+          );
         }
 
         if (paramsSerializer != null) {
           if (utils$1.isFunction(paramsSerializer)) {
             config.paramsSerializer = {
-              serialize: paramsSerializer
+              serialize: paramsSerializer,
             };
           } else {
-            validator.assertOptions(paramsSerializer, {
-              encode: validators.function,
-              serialize: validators.function
-            }, true);
+            validator.assertOptions(
+              paramsSerializer,
+              {
+                encode: validators.function,
+                serialize: validators.function,
+              },
+              true
+            );
           }
         }
 
+        // Set config.allowAbsoluteUrls
+        if (config.allowAbsoluteUrls !== undefined) ; else if (this.defaults.allowAbsoluteUrls !== undefined) {
+          config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
+        } else {
+          config.allowAbsoluteUrls = true;
+        }
+
+        validator.assertOptions(
+          config,
+          {
+            baseUrl: validators.spelling('baseURL'),
+            withXsrfToken: validators.spelling('withXSRFToken'),
+          },
+          true
+        );
+
         // Set config.method
         config.method = (config.method || this.defaults.method || 'get').toLowerCase();
 
         // Flatten headers
-        let contextHeaders = headers && utils$1.merge(
-          headers.common,
-          headers[config.method]
-        );
+        let contextHeaders = headers && utils$1.merge(headers.common, headers[config.method]);
 
-        headers && utils$1.forEach(
-          ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
-          (method) => {
+        headers &&
+          utils$1.forEach(['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], (method) => {
             delete headers[method];
-          }
-        );
+          });
 
         config.headers = AxiosHeaders$1.concat(contextHeaders, headers);
 
@@ -35180,7 +36195,15 @@
 
           synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
 
-          requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+          const transitional = config.transitional || transitionalDefaults;
+          const legacyInterceptorReqResOrdering =
+            transitional && transitional.legacyInterceptorReqResOrdering;
+
+          if (legacyInterceptorReqResOrdering) {
+            requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+          } else {
+            requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+          }
         });
 
         const responseInterceptorChain = [];
@@ -35194,8 +36217,8 @@
 
         if (!synchronousRequestInterceptors) {
           const chain = [dispatchRequest.bind(this), undefined];
-          chain.unshift.apply(chain, requestInterceptorChain);
-          chain.push.apply(chain, responseInterceptorChain);
+          chain.unshift(...requestInterceptorChain);
+          chain.push(...responseInterceptorChain);
           len = chain.length;
 
           promise = Promise.resolve(config);
@@ -35211,8 +36234,6 @@
 
         let newConfig = config;
 
-        i = 0;
-
         while (i < len) {
           const onFulfilled = requestInterceptorChain[i++];
           const onRejected = requestInterceptorChain[i++];
@@ -35242,7 +36263,7 @@
 
       getUri(config) {
         config = mergeConfig$1(this.defaults, config);
-        const fullPath = buildFullPath(config.baseURL, config.url);
+        const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
         return buildURL(fullPath, config.params, config.paramsSerializer);
       }
     };
@@ -35250,28 +36271,32 @@
     // Provide aliases for supported request methods
     utils$1.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
       /*eslint func-names:0*/
-      Axios$1.prototype[method] = function(url, config) {
-        return this.request(mergeConfig$1(config || {}, {
-          method,
-          url,
-          data: (config || {}).data
-        }));
+      Axios$1.prototype[method] = function (url, config) {
+        return this.request(
+          mergeConfig$1(config || {}, {
+            method,
+            url,
+            data: (config || {}).data,
+          })
+        );
       };
     });
 
     utils$1.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
-      /*eslint func-names:0*/
-
       function generateHTTPMethod(isForm) {
         return function httpMethod(url, data, config) {
-          return this.request(mergeConfig$1(config || {}, {
-            method,
-            headers: isForm ? {
-              'Content-Type': 'multipart/form-data'
-            } : {},
-            url,
-            data
-          }));
+          return this.request(
+            mergeConfig$1(config || {}, {
+              method,
+              headers: isForm
+                ? {
+                    'Content-Type': 'multipart/form-data',
+                  }
+                : {},
+              url,
+              data,
+            })
+          );
         };
       }
 
@@ -35302,7 +36327,7 @@
         const token = this;
 
         // eslint-disable-next-line func-names
-        this.promise.then(cancel => {
+        this.promise.then((cancel) => {
           if (!token._listeners) return;
 
           let i = token._listeners.length;
@@ -35314,10 +36339,10 @@
         });
 
         // eslint-disable-next-line func-names
-        this.promise.then = onfulfilled => {
+        this.promise.then = (onfulfilled) => {
           let _resolve;
           // eslint-disable-next-line func-names
-          const promise = new Promise(resolve => {
+          const promise = new Promise((resolve) => {
             token.subscribe(resolve);
             _resolve = resolve;
           }).then(onfulfilled);
@@ -35380,6 +36405,20 @@
         }
       }
 
+      toAbortSignal() {
+        const controller = new AbortController();
+
+        const abort = (err) => {
+          controller.abort(err);
+        };
+
+        this.subscribe(abort);
+
+        controller.signal.unsubscribe = () => this.unsubscribe(abort);
+
+        return controller.signal;
+      }
+
       /**
        * Returns an object that contains a new `CancelToken` and a function that, when called,
        * cancels the `CancelToken`.
@@ -35391,7 +36430,7 @@
         });
         return {
           token,
-          cancel
+          cancel,
         };
       }
     };
@@ -35403,7 +36442,7 @@
      *
      *  ```js
      *  function f(x, y, z) {}
-     *  var args = [1, 2, 3];
+     *  const args = [1, 2, 3];
      *  f.apply(null, args);
      *  ```
      *
@@ -35431,7 +36470,7 @@
      * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
      */
     function isAxiosError$1(payload) {
-      return utils$1.isObject(payload) && (payload.isAxiosError === true);
+      return utils$1.isObject(payload) && payload.isAxiosError === true;
     }
 
     const HttpStatusCode$1 = {
@@ -35498,6 +36537,12 @@
       LoopDetected: 508,
       NotExtended: 510,
       NetworkAuthenticationRequired: 511,
+      WebServerIsDown: 521,
+      ConnectionTimedOut: 522,
+      OriginIsUnreachable: 523,
+      TimeoutOccurred: 524,
+      SslHandshakeFailed: 525,
+      InvalidSslCertificate: 526,
     };
 
     Object.entries(HttpStatusCode$1).forEach(([key, value]) => {
@@ -35516,10 +36561,10 @@
       const instance = bind(Axios$1.prototype.request, context);
 
       // Copy axios.prototype to instance
-      utils$1.extend(instance, Axios$1.prototype, context, {allOwnKeys: true});
+      utils$1.extend(instance, Axios$1.prototype, context, { allOwnKeys: true });
 
       // Copy context to instance
-      utils$1.extend(instance, context, null, {allOwnKeys: true});
+      utils$1.extend(instance, context, null, { allOwnKeys: true });
 
       // Factory for creating new instances
       instance.create = function create(instanceConfig) {
@@ -35563,7 +36608,7 @@
 
     axios.AxiosHeaders = AxiosHeaders$1;
 
-    axios.formToJSON = thing => formDataToJSON(utils$1.isHTMLForm(thing) ? new FormData(thing) : thing);
+    axios.formToJSON = (thing) => formDataToJSON(utils$1.isHTMLForm(thing) ? new FormData(thing) : thing);
 
     axios.getAdapter = adapters.getAdapter;
 
@@ -35590,7 +36635,7 @@
       HttpStatusCode,
       formToJSON,
       getAdapter,
-      mergeConfig
+      mergeConfig,
     } = axios;
 
     const prodFunctionsBaseUrl = "https://us-central1-neurosity-device.cloudfunctions.net";
@@ -35982,7 +37027,7 @@
     function requireBuffer () {
     	if (hasRequiredBuffer) return buffer;
     	hasRequiredBuffer = 1;
-    	(function (exports) {
+    	(function (exports$1) {
 
     		const base64 = requireBase64Js();
     		const ieee754 = requireIeee754();
@@ -35991,12 +37036,12 @@
     		    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation
     		    : null;
 
-    		exports.Buffer = Buffer;
-    		exports.SlowBuffer = SlowBuffer;
-    		exports.INSPECT_MAX_BYTES = 50;
+    		exports$1.Buffer = Buffer;
+    		exports$1.SlowBuffer = SlowBuffer;
+    		exports$1.INSPECT_MAX_BYTES = 50;
 
     		const K_MAX_LENGTH = 0x7fffffff;
-    		exports.kMaxLength = K_MAX_LENGTH;
+    		exports$1.kMaxLength = K_MAX_LENGTH;
 
     		/**
     		 * If `Buffer.TYPED_ARRAY_SUPPORT`:
@@ -36592,7 +37637,7 @@
 
     		Buffer.prototype.inspect = function inspect () {
     		  let str = '';
-    		  const max = exports.INSPECT_MAX_BYTES;
+    		  const max = exports$1.INSPECT_MAX_BYTES;
     		  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim();
     		  if (this.length > max) str += ' ... ';
     		  return '<Buffer ' + str + '>'
@@ -39017,6 +40062,7 @@
             this._brainwavesPowerByBand$ =
                 this._subscribeWhileAuthenticated("powerByBand");
             this._signalQuality$ = this._subscribeWhileAuthenticated("signalQuality");
+            this._signalQualityV2$ = this._subscribeWhileAuthenticated("signalQualityV2");
             this._status$ = this._subscribeWhileAuthenticated("status");
             this._settings$ = this._subscribeWhileAuthenticated("settings");
             this._wifiNearbyNetworks$ =
@@ -39153,6 +40199,9 @@
         signalQuality() {
             return this._signalQuality$;
         }
+        signalQualityV2() {
+            return this._signalQualityV2$;
+        }
         async addMarker(label) {
             await this.dispatchAction({
                 action: "marker",
@@ -39315,20 +40364,20 @@
     function requireRe () {
     	if (hasRequiredRe) return re.exports;
     	hasRequiredRe = 1;
-    	(function (module, exports) {
+    	(function (module, exports$1) {
     		const {
     		  MAX_SAFE_COMPONENT_LENGTH,
     		  MAX_SAFE_BUILD_LENGTH,
     		  MAX_LENGTH,
     		} = requireConstants();
     		const debug = requireDebug();
-    		exports = module.exports = {};
+    		exports$1 = module.exports = {};
 
     		// The actual regexps go on exports.re
-    		const re = exports.re = [];
-    		const safeRe = exports.safeRe = [];
-    		const src = exports.src = [];
-    		const t = exports.t = {};
+    		const re = exports$1.re = [];
+    		const safeRe = exports$1.safeRe = [];
+    		const src = exports$1.src = [];
+    		const t = exports$1.t = {};
     		let R = 0;
 
     		const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
@@ -39489,7 +40538,7 @@
     		createToken('LONETILDE', '(?:~>?)');
 
     		createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-    		exports.tildeTrimReplace = '$1~';
+    		exports$1.tildeTrimReplace = '$1~';
 
     		createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
     		createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
@@ -39499,7 +40548,7 @@
     		createToken('LONECARET', '(?:\\^)');
 
     		createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
-    		exports.caretTrimReplace = '$1^';
+    		exports$1.caretTrimReplace = '$1^';
 
     		createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
     		createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
@@ -39512,7 +40561,7 @@
     		// it modifies, so that `> 1.2.3` ==> `>1.2.3`
     		createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
 		}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-    		exports.comparatorTrimReplace = '$1$2$3';
+    		exports$1.comparatorTrimReplace = '$1$2$3';
 
     		// Something like `1.2.3 - 1.2.4`
     		// Note that these all use the loose form, because they'll be
@@ -40294,6 +41343,127 @@
                 bluetooth: () => this.bluetoothClient.brainwaves(label)
             });
         }
+        async record(options) {
+            var _a;
+            if (!(await this.cloudClient.didSelectDevice())) {
+                return Promise.reject(mustSelectDevice);
+            }
+            const [hasOAuthError, OAuthError] = validateScopeBasedPermissionForAction(this.cloudClient.userClaims, {
+                command: "brainwaves",
+                action: "record"});
+            if (hasOAuthError) {
+                return Promise.reject(OAuthError);
+            }
+            if (!options.label) {
+                return Promise.reject(new Error(`${prefix}A label is required for record.`));
+            }
+            if (!options.duration || options.duration <= 0) {
+                return Promise.reject(new Error(`${prefix}A positive duration is required for record.`));
+            }
+            const MAX_DURATION = 30 * 60 * 1000;
+            if (options.duration > MAX_DURATION) {
+                return Promise.reject(new Error(`${prefix}Duration ${options.duration}ms exceeds maximum of ${MAX_DURATION}ms (30 minutes).`));
+            }
+            const response = await this.dispatchAction({
+                command: "brainwaves",
+                action: "record",
+                message: {
+                    name: options.name || options.label,
+                    label: options.label,
+                    duration: options.duration,
+                    experimentId: options.experimentId || "sdk-recording"
+                },
+                responseRequired: true,
+                responseTimeout: options.duration + 90000
+            });
+            return (_a = response === null || response === void 0 ? void 0 : response.message) !== null && _a !== void 0 ? _a : response;
+        }
+        async startRecording(options) {
+            var _a;
+            if (!(await this.cloudClient.didSelectDevice())) {
+                return Promise.reject(mustSelectDevice);
+            }
+            const [hasOAuthError, OAuthError] = validateScopeBasedPermissionForAction(this.cloudClient.userClaims, {
+                command: "brainwaves",
+                action: "startRecording"});
+            if (hasOAuthError) {
+                return Promise.reject(OAuthError);
+            }
+            if (!options.label) {
+                return Promise.reject(new Error(`${prefix}A label is required for startRecording.`));
+            }
+            if (!options.maxDuration || options.maxDuration <= 0) {
+                return Promise.reject(new Error(`${prefix}A positive maxDuration is required for startRecording.`));
+            }
+            const MAX_DURATION = 30 * 60 * 1000;
+            if (options.maxDuration > MAX_DURATION) {
+                return Promise.reject(new Error(`${prefix}Duration ${options.maxDuration}ms exceeds maximum of ${MAX_DURATION}ms (30 minutes).`));
+            }
+            const response = await this.dispatchAction({
+                command: "brainwaves",
+                action: "startRecording",
+                message: {
+                    name: options.name || options.label,
+                    label: options.label,
+                    maxDuration: options.maxDuration,
+                    experimentId: options.experimentId || "sdk-recording"
+                },
+                responseRequired: true,
+                responseTimeout: options.maxDuration + 10000
+            });
+            const startResponse = (_a = response === null || response === void 0 ? void 0 : response.message) !== null && _a !== void 0 ? _a : response;
+            if (!(startResponse === null || startResponse === void 0 ? void 0 : startResponse.ok)) {
+                return Promise.reject(new Error(`${prefix}Failed to start recording: ${(startResponse === null || startResponse === void 0 ? void 0 : startResponse.error) || "unknown error"}`));
+            }
+            const { cancel: cancelAction, complete: completeAction } = startResponse;
+            const startTime = Date.now();
+            let stopped = false;
+            let resolveResult;
+            const resultPromise = new Promise((resolve) => {
+                resolveResult = resolve;
+            });
+            const elapsedSubscribers = new Set();
+            const elapsed$ = new Observable((subscriber) => {
+                elapsedSubscribers.add(subscriber);
+                const timer = setInterval(() => {
+                    subscriber.next(Date.now() - startTime);
+                }, 1000);
+                return () => {
+                    clearInterval(timer);
+                    elapsedSubscribers.delete(subscriber);
+                };
+            });
+            const completeAllElapsed = () => {
+                for (const sub of elapsedSubscribers) {
+                    sub.complete();
+                }
+            };
+            const stop = async () => {
+                var _a, _b;
+                if (stopped)
+                    return resultPromise;
+                stopped = true;
+                completeAllElapsed();
+                const stopResponse = await this.dispatchAction(completeAction);
+                const result = (_b = (_a = stopResponse === null || stopResponse === void 0 ? void 0 : stopResponse.message) !== null && _a !== void 0 ? _a : stopResponse) !== null && _b !== void 0 ? _b : { ok: true };
+                resolveResult(result);
+                return result;
+            };
+            const cancel = async () => {
+                if (stopped)
+                    return;
+                stopped = true;
+                completeAllElapsed();
+                await this.dispatchAction(cancelAction);
+                resolveResult({ ok: false, error: "cancelled" });
+            };
+            return {
+                elapsed$,
+                stop,
+                cancel,
+                result: resultPromise
+            };
+        }
         calm() {
             const [hasOAuthError, OAuthError] = validateScopeBasedPermissionForFunctionName(this.cloudClient.userClaims, "calm");
             if (hasOAuthError) {
@@ -40323,6 +41493,21 @@
                 bluetooth: () => this.bluetoothClient.signalQuality()
             });
         }
+        signalQualityV2() {
+            const metric = "signalQualityV2";
+            const [hasOAuthError, OAuthError] = validateScopeBasedPermissionForFunctionName(this.cloudClient.userClaims, "signalQuality");
+            if (hasOAuthError) {
+                return throwError(() => OAuthError);
+            }
+            return this._withStreamingModeObservable({
+                wifi: () => getCloudMetric(this._getCloudMetricDependencies(), {
+                    metric,
+                    labels: getLabels(metric),
+                    atomic: true
+                }),
+                bluetooth: () => this.bluetoothClient.signalQualityV2()
+            });
+        }
         settings() {
             const [hasOAuthError, OAuthError] = validateScopeBasedPermissionForFunctionName(this.cloudClient.userClaims, "settings");
             if (hasOAuthError) {