@passkeyme/auth 2.0.10 → 2.0.12

package/dist/index.umd.js

@@ -828,7 +828,7 @@
             const defaultRedirectUri = typeof window !== "undefined" && window.location && window.location.origin
                 ? `${window.location.origin}/auth/callback`
                 : "http://localhost:3000/auth/callback";
-            // Use baseUrl for auth endpoints, apiUrl is separate for API calls
+            // Base URL for hosted auth UI pages - defaults to auth.passkeyme.com
             const serverUrl = config.baseUrl || "https://auth.passkeyme.com";
             console.log("[DEBUG] serverUrl determined as:", serverUrl);
             this.config = {
@@ -1019,11 +1019,15 @@
          */
         redirectToOAuth(provider, redirectUri) {
             const finalRedirectUri = redirectUri || this.config.redirectUri;
-            // Build direct OAuth initiation URL
+            // Build direct OAuth initiation URL - use apiUrl for backend API endpoints
+            const apiBaseUrl = this.config.apiUrl ||
+                (typeof window !== "undefined" && window.location.hostname !== "localhost"
+                    ? "https://api.passkeyme.com"
+                    : "http://localhost:8000");
             const params = new URLSearchParams({
                 redirect_uri: finalRedirectUri,
             });
-            const oauthUrl = `${this.config.baseUrl}/auth/${this.config.appId}/oauth/${provider}/start?${params.toString()}`;
+            const oauthUrl = `${apiBaseUrl}/auth/${this.config.appId}/oauth/${provider}/start?${params.toString()}`;
             logger.debug("Redirecting directly to OAuth provider:", provider, oauthUrl);
             this.performRedirect(oauthUrl, finalRedirectUri);
         }
@@ -1431,6 +1435,19 @@
                 }
                 // Extract token and user info from response
                 const { token, user_uuid, success, message } = completeResponse.data;
+                // Decode JWT to extract email and other user info
+                let tokenEmail;
+                try {
+                    const tokenParts = token.split(".");
+                    if (tokenParts.length === 3) {
+                        const payload = JSON.parse(atob(tokenParts[1]));
+                        tokenEmail = payload.email;
+                        logger.debug("Extracted email from JWT:", tokenEmail);
+                    }
+                }
+                catch (decodeError) {
+                    logger.debug("Failed to decode JWT token:", decodeError);
+                }
                 // Store tokens - use the JWT token as access token
                 const tokens = {
                     accessToken: token,
@@ -1439,11 +1456,13 @@
                 };
                 await this.tokenStorage.setTokens(tokens);
                 // Create user object with available information
+                // Prefer email from JWT token, fallback to username
+                const userEmail = tokenEmail || username;
                 const user = {
                     id: user_uuid,
                     uuid: user_uuid,
                     username: username,
-                    email: username, // Assume username is email for now
+                    email: userEmail,
                     authenticated: true,
                 };
                 // Update state
@@ -1833,6 +1852,13 @@
         return new PasskeymeAuth(config);
     }
 
+    /**
+     * 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);
@@ -1884,7 +1910,7 @@
      */
     function isBuffer(val) {
       return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
-        && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+        && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);
     }
 
     /**
@@ -1929,7 +1955,7 @@
      * @param {*} val The value to test
      * @returns {boolean} True if value is a Function, otherwise false
      */
-    const isFunction = typeOfTest('function');
+    const isFunction$1 = typeOfTest('function');
 
     /**
      * Determine if a value is a Number
@@ -1985,7 +2011,7 @@
       if (!isObject(val) || isBuffer(val)) {
         return false;
       }
-      
+
       try {
         return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
       } catch (e) {
@@ -2037,7 +2063,7 @@
      *
      * @returns {boolean} True if value is a Stream, otherwise false
      */
-    const isStream = (val) => isObject(val) && isFunction(val.pipe);
+    const isStream = (val) => isObject(val) && isFunction$1(val.pipe);
 
     /**
      * Determine if a value is a FormData
@@ -2050,10 +2076,10 @@
       let kind;
       return thing && (
         (typeof FormData === 'function' && thing instanceof FormData) || (
-          isFunction(thing.append) && (
+          isFunction$1(thing.append) && (
             (kind = kindOf(thing)) === 'formdata' ||
             // detect form-data instance
-            (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')
+            (kind === 'object' && isFunction$1(thing.toString) && thing.toString() === '[object FormData]')
           )
         )
       )
@@ -2178,7 +2204,7 @@
      * @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;
@@ -2188,7 +2214,7 @@
           result[targetKey] = merge({}, val);
         } else if (isArray(val)) {
           result[targetKey] = val.slice();
-        } else {
+        } else if (!skipUndefined || !isUndefined(val)) {
           result[targetKey] = val;
         }
       };
@@ -2211,7 +2237,7 @@
      */
     const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
       forEach(b, (val, key) => {
-        if (thisArg && isFunction(val)) {
+        if (thisArg && isFunction$1(val)) {
           a[key] = bind(val, thisArg);
         } else {
           a[key] = val;
@@ -2427,13 +2453,13 @@
     const freezeMethods = (obj) => {
       reduceDescriptors(obj, (descriptor, name) => {
         // skip restricted props in strict mode
-        if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
+        if (isFunction$1(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
           return false;
         }
 
         const value = obj[name];
 
-        if (!isFunction(value)) return;
+        if (!isFunction$1(value)) return;
 
         descriptor.enumerable = false;
 
@@ -2470,6 +2496,8 @@
       return value != null && Number.isFinite(value = +value) ? value : defaultValue;
     };
 
+
+
     /**
      * If the thing is a FormData object, return true, otherwise return false.
      *
@@ -2478,7 +2506,7 @@
      * @returns {boolean}
      */
     function isSpecCompliantForm(thing) {
-      return !!(thing && isFunction(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
+      return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
     }
 
     const toJSONObject = (obj) => {
@@ -2520,7 +2548,7 @@
     const isAsyncFn = kindOfTest('AsyncFunction');
 
     const isThenable = (thing) =>
-      thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
+      thing && (isObject(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
 
     // original code
     // https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
@@ -2544,7 +2572,7 @@
       })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
     })(
       typeof setImmediate === 'function',
-      isFunction(_global.postMessage)
+      isFunction$1(_global.postMessage)
     );
 
     const asap = typeof queueMicrotask !== 'undefined' ?
@@ -2553,7 +2581,7 @@
     // *********************
 
 
-    const isIterable = (thing) => thing != null && isFunction(thing[iterator]);
+    const isIterable = (thing) => thing != null && isFunction$1(thing[iterator]);
 
 
     var utils$1 = {
@@ -2577,7 +2605,7 @@
       isFile,
       isBlob,
       isRegExp,
-      isFunction,
+      isFunction: isFunction$1,
       isStream,
       isURLSearchParams,
       isTypedArray,
@@ -2703,11 +2731,18 @@
         return prop !== 'isAxiosError';
       });
 
-      AxiosError.call(axiosError, error.message, code, config, request, response);
+      const msg = error && error.message ? error.message : 'Error';
+
+      // Prefer explicit code; otherwise copy the low-level error's code (e.g. ECONNREFUSED)
+      const errCode = code == null && error ? error.code : code;
+      AxiosError.call(axiosError, msg, errCode, config, request, response);
 
-      axiosError.cause = error;
+      // Chain the original error on the standard field; non-enumerable to avoid JSON noise
+      if (error && axiosError.cause == null) {
+        Object.defineProperty(axiosError, 'cause', { value: error, configurable: true });
+      }
 
-      axiosError.name = error.name;
+      axiosError.name = (error && error.name) || 'Error';
 
       customProps && Object.assign(axiosError, customProps);
 
@@ -2998,9 +3033,7 @@
         replace(/%3A/gi, ':').
         replace(/%24/g, '$').
         replace(/%2C/gi, ',').
-        replace(/%20/g, '+').
-        replace(/%5B/gi, '[').
-        replace(/%5D/gi, ']');
+        replace(/%20/g, '+');
     }
 
     /**
@@ -3078,7 +3111,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]) {
@@ -3405,7 +3438,7 @@
           const strictJSONParsing = !silentJSONParsing && JSONRequested;
 
           try {
-            return JSON.parse(data);
+            return JSON.parse(data, this.parseReviver);
           } catch (e) {
             if (strictJSONParsing) {
               if (e.name === 'SyntaxError') {
@@ -4044,27 +4077,38 @@
 
       // 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);
+        write(name, value, expires, path, domain, secure, sameSite) {
+          if (typeof document === 'undefined') return;
 
-          utils$1.isString(domain) && cookie.push('domain=' + domain);
+          const cookie = [`${name}=${encodeURIComponent(value)}`];
 
-          secure === true && cookie.push('secure');
+          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) {
-          const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
-          return (match ? decodeURIComponent(match[3]) : null);
+          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);
+          this.write(name, '', Date.now() - 86400000, '/');
         }
       }
 
@@ -4153,11 +4197,11 @@
       }
 
       // eslint-disable-next-line consistent-return
-      function mergeDeepProperties(a, b, prop , caseless) {
+      function mergeDeepProperties(a, b, prop, caseless) {
         if (!utils$1.isUndefined(b)) {
-          return getMergedValue(a, b, prop , caseless);
+          return getMergedValue(a, b, prop, caseless);
         } else if (!utils$1.isUndefined(a)) {
-          return getMergedValue(undefined, a, prop , caseless);
+          return getMergedValue(undefined, a, prop, caseless);
         }
       }
 
@@ -4215,7 +4259,7 @@
         socketPath: defaultToConfig2,
         responseEncoding: defaultToConfig2,
         validateStatus: mergeDirectKeys,
-        headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)
+        headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
       };
 
       utils$1.forEach(Object.keys({...config1, ...config2}), function computeConfigValue(prop) {
@@ -4230,7 +4274,7 @@
     var resolveConfig = (config) => {
       const newConfig = mergeConfig({}, config);
 
-      let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;
+      let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
 
       newConfig.headers = headers = AxiosHeaders$1.from(headers);
 
@@ -4243,17 +4287,21 @@
         );
       }
 
-      let contentType;
-
       if (utils$1.isFormData(data)) {
         if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
-          headers.setContentType(undefined); // Let the browser set it
-        } else if ((contentType = headers.getContentType()) !== false) {
-          // fix semicolon duplication issue for ReactNative FormData implementation
-          const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];
-          headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));
+          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.
@@ -4370,15 +4418,18 @@
         };
 
         // 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('Network Error', AxiosError.ERR_NETWORK, config, request));
-
-          // Clean up request
-          request = null;
+      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(msg, AxiosError.ERR_NETWORK, config, request);
+           // attach the underlying event for consumers who want details
+           err.event = event || null;
+           reject(err);
+           request = null;
         };
-
+        
         // Handle timeout
         request.ontimeout = function handleTimeout() {
           let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';
@@ -4594,14 +4645,18 @@
       })
     };
 
-    const isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function';
-    const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function';
+    const DEFAULT_CHUNK_SIZE = 64 * 1024;
+
+    const {isFunction} = utils$1;
+
+    const globalFetchAPI = (({Request, Response}) => ({
+      Request, Response
+    }))(utils$1.global);
+
+    const {
+      ReadableStream: ReadableStream$1, TextEncoder
+    } = utils$1.global;
 
-    // used only inside the fetch adapter
-    const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
-        ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
-        async (str) => new Uint8Array(await new Response(str).arrayBuffer())
-    );
 
     const test = (fn, ...args) => {
       try {
@@ -4611,278 +4666,380 @@
       }
     };
 
-    const supportsRequestStream = isReadableStreamSupported && test(() => {
-      let duplexAccessed = false;
+    const factory = (env) => {
+      env = utils$1.merge.call({
+        skipUndefined: true
+      }, globalFetchAPI, env);
 
-      const hasContentType = new Request(platform.origin, {
-        body: new ReadableStream(),
-        method: 'POST',
-        get duplex() {
-          duplexAccessed = true;
-          return 'half';
-        },
-      }).headers.has('Content-Type');
+      const {fetch: envFetch, Request, Response} = env;
+      const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';
+      const isRequestSupported = isFunction(Request);
+      const isResponseSupported = isFunction(Response);
 
-      return duplexAccessed && !hasContentType;
-    });
+      if (!isFetchSupported) {
+        return false;
+      }
 
-    const DEFAULT_CHUNK_SIZE = 64 * 1024;
+      const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream$1);
 
-    const supportsResponseStream = isReadableStreamSupported &&
-      test(() => utils$1.isReadableStream(new Response('').body));
+      const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
+          ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
+          async (str) => new Uint8Array(await new Request(str).arrayBuffer())
+      );
 
+      const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
+        let duplexAccessed = false;
 
-    const resolvers = {
-      stream: supportsResponseStream && ((res) => res.body)
-    };
+        const hasContentType = new Request(platform.origin, {
+          body: new ReadableStream$1(),
+          method: 'POST',
+          get duplex() {
+            duplexAccessed = true;
+            return 'half';
+          },
+        }).headers.has('Content-Type');
 
-    isFetchSupported && (((res) => {
-      ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
-        !resolvers[type] && (resolvers[type] = utils$1.isFunction(res[type]) ? (res) => res[type]() :
-          (_, config) => {
-            throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
-          });
+        return duplexAccessed && !hasContentType;
       });
-    })(new Response));
 
-    const getBodyLength = async (body) => {
-      if (body == null) {
-        return 0;
-      }
+      const supportsResponseStream = isResponseSupported && isReadableStreamSupported &&
+        test(() => utils$1.isReadableStream(new Response('').body));
 
-      if(utils$1.isBlob(body)) {
-        return body.size;
-      }
+      const resolvers = {
+        stream: supportsResponseStream && ((res) => res.body)
+      };
 
-      if(utils$1.isSpecCompliantForm(body)) {
-        const _request = new Request(platform.origin, {
-          method: 'POST',
-          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);
+            }
+
+            throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
+          });
         });
-        return (await _request.arrayBuffer()).byteLength;
-      }
+      })());
 
-      if(utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
-        return body.byteLength;
-      }
+      const getBodyLength = async (body) => {
+        if (body == null) {
+          return 0;
+        }
 
-      if(utils$1.isURLSearchParams(body)) {
-        body = body + '';
-      }
+        if (utils$1.isBlob(body)) {
+          return body.size;
+        }
 
-      if(utils$1.isString(body)) {
-        return (await encodeText(body)).byteLength;
-      }
-    };
+        if (utils$1.isSpecCompliantForm(body)) {
+          const _request = new Request(platform.origin, {
+            method: 'POST',
+            body,
+          });
+          return (await _request.arrayBuffer()).byteLength;
+        }
 
-    const resolveBodyLength = async (headers, body) => {
-      const length = utils$1.toFiniteNumber(headers.getContentLength());
+        if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
+          return body.byteLength;
+        }
 
-      return length == null ? getBodyLength(body) : length;
-    };
+        if (utils$1.isURLSearchParams(body)) {
+          body = body + '';
+        }
+
+        if (utils$1.isString(body)) {
+          return (await encodeText(body)).byteLength;
+        }
+      };
 
-    var fetchAdapter = isFetchSupported && (async (config) => {
-      let {
-        url,
-        method,
-        data,
-        signal,
-        cancelToken,
-        timeout,
-        onDownloadProgress,
-        onUploadProgress,
-        responseType,
-        headers,
-        withCredentials = 'same-origin',
-        fetchOptions
-      } = resolveConfig(config);
-
-      responseType = responseType ? (responseType + '').toLowerCase() : 'text';
-
-      let composedSignal = composeSignals$1([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
-
-      let request;
-
-      const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+      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$1([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
+
+        let request = null;
+
+        const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
           composedSignal.unsubscribe();
-      });
+        });
 
-      let requestContentLength;
+        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"
-          });
+        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;
+            let contentTypeHeader;
 
-          if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
-            headers.setContentType(contentTypeHeader);
-          }
+            if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
+              headers.setContentType(contentTypeHeader);
+            }
 
-          if (_request.body) {
-            const [onProgress, flush] = progressEventDecorator(
-              requestContentLength,
-              progressEventReducer(asyncDecorator(onUploadProgress))
-            );
+            if (_request.body) {
+              const [onProgress, flush] = progressEventDecorator(
+                requestContentLength,
+                progressEventReducer(asyncDecorator(onUploadProgress))
+              );
 
-            data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+              data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+            }
           }
-        }
 
-        if (!utils$1.isString(withCredentials)) {
-          withCredentials = withCredentials ? 'include' : 'omit';
-        }
+          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 = "credentials" in Request.prototype;
-        request = new Request(url, {
-          ...fetchOptions,
-          signal: composedSignal,
-          method: method.toUpperCase(),
-          headers: headers.normalize().toJSON(),
-          body: data,
-          duplex: "half",
-          credentials: isCredentialsSupported ? withCredentials : undefined
-        });
+          // Cloudflare Workers throws when credentials are defined
+          // see https://github.com/cloudflare/workerd/issues/902
+          const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
 
-        let response = await fetch(request, fetchOptions);
+          const resolvedOptions = {
+            ...fetchOptions,
+            signal: composedSignal,
+            method: method.toUpperCase(),
+            headers: headers.normalize().toJSON(),
+            body: data,
+            duplex: "half",
+            credentials: isCredentialsSupported ? withCredentials : undefined
+          };
 
-        const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
+          request = isRequestSupported && new Request(url, resolvedOptions);
 
-        if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
-          const options = {};
+          let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
 
-          ['status', 'statusText', 'headers'].forEach(prop => {
-            options[prop] = response[prop];
-          });
+          const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
 
-          const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
+          if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
+            const options = {};
 
-          const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
-            responseContentLength,
-            progressEventReducer(asyncDecorator(onDownloadProgress), true)
-          ) || [];
+            ['status', 'statusText', 'headers'].forEach(prop => {
+              options[prop] = response[prop];
+            });
 
-          response = new Response(
-            trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
-              flush && flush();
-              unsubscribe && unsubscribe();
-            }),
-            options
-          );
-        }
+            const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
 
-        responseType = responseType || 'text';
+            const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
+              responseContentLength,
+              progressEventReducer(asyncDecorator(onDownloadProgress), true)
+            ) || [];
 
-        let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](response, config);
+            response = new Response(
+              trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+                flush && flush();
+                unsubscribe && unsubscribe();
+              }),
+              options
+            );
+          }
 
-        !isStreamResponse && unsubscribe && unsubscribe();
+          responseType = responseType || 'text';
 
-        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('Network Error', AxiosError.ERR_NETWORK, config, request),
-            {
-              cause: err.cause || err
-            }
-          )
+          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('Network Error', AxiosError.ERR_NETWORK, config, request),
+              {
+                cause: err.cause || err
+              }
+            )
+          }
+
+          throw AxiosError.from(err, err && err.code, config, request);
         }
+      }
+    };
+
+    const seedCache = new Map();
+
+    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);
 
-        throw AxiosError.from(err, err && err.code, config, request);
+        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,
-      fetch: fetchAdapter
+      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}`;
 
+    /**
+     * 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];
-
-        const {length} = adapters;
-        let nameOrAdapter;
-        let adapter;
+    /**
+     * 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(adapters, config) {
+      adapters = utils$1.isArray(adapters) ? adapters : [adapters];
 
-        const rejectedReasons = {};
+      const { length } = adapters;
+      let nameOrAdapter;
+      let adapter;
 
-        for (let i = 0; i < length; i++) {
-          nameOrAdapter = adapters[i];
-          let id;
+      const rejectedReasons = {};
 
-          adapter = nameOrAdapter;
+      for (let i = 0; i < length; i++) {
+        nameOrAdapter = adapters[i];
+        let id;
 
-          if (!isResolvedHandle(nameOrAdapter)) {
-            adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+        adapter = nameOrAdapter;
 
-            if (adapter === undefined) {
-              throw new AxiosError(`Unknown adapter '${id}'`);
-            }
-          }
+        if (!isResolvedHandle(nameOrAdapter)) {
+          adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
 
-          if (adapter) {
-            break;
+          if (adapter === undefined) {
+            throw new AxiosError(`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(
-            `There is no suitable adapter to dispatch the request ` + s,
-            'ERR_NOT_SUPPORT'
-          );
-        }
+        throw new AxiosError(
+          `There is no suitable adapter to dispatch the request ` + s,
+          'ERR_NOT_SUPPORT'
+        );
+      }
 
-        return adapter;
-      },
+      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,
+
+      /**
+       * Exposes all known adapters
+       * @type {Object<string, Function|Object>}
+       */
       adapters: knownAdapters
     };
 
@@ -4925,7 +5082,7 @@
         config.headers.setContentType('application/x-www-form-urlencoded', false);
       }
 
-      const adapter = adapters.getAdapter(config.adapter || defaults$1.adapter);
+      const adapter = adapters.getAdapter(config.adapter || defaults$1.adapter, config);
 
       return adapter(config).then(function onAdapterResolution(response) {
         throwIfCancellationRequested(config);
@@ -4959,7 +5116,7 @@
       });
     }
 
-    const VERSION = "1.11.0";
+    const VERSION = "1.13.2";
 
     const validators$1 = {};
 
@@ -5215,8 +5372,6 @@
 
         let newConfig = config;
 
-        i = 0;
-
         while (i < len) {
           const onFulfilled = requestInterceptorChain[i++];
           const onRejected = requestInterceptorChain[i++];
@@ -5520,6 +5675,12 @@
       LoopDetected: 508,
       NotExtended: 510,
       NetworkAuthenticationRequired: 511,
+      WebServerIsDown: 521,
+      ConnectionTimedOut: 522,
+      OriginIsUnreachable: 523,
+      TimeoutOccurred: 524,
+      SslHandshakeFailed: 525,
+      InvalidSslCertificate: 526,
     };
 
     Object.entries(HttpStatusCode).forEach(([key, value]) => {