axios 1.18.0 → 1.19.0

package/index.d.ts

@@ -3,6 +3,8 @@ type StringLiteralsOrString<Literals extends string> = Literals | (string & {});
 
 export type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;
 
+export type AxiosHeaderParameters = Record<string, string>;
+
 export interface RawAxiosHeaders {
   [key: string]: AxiosHeaderValue;
 }
@@ -31,7 +33,9 @@ export class AxiosHeaders {
     rewrite?: boolean | AxiosHeaderMatcher
   ): AxiosHeaders;
   set(headers?: RawAxiosHeaders | AxiosHeaders | string, rewrite?: boolean): AxiosHeaders;
+  set(headers?: Iterable<[string, AxiosHeaderValue]>, rewrite?: boolean): AxiosHeaders;
 
+  get(headerName: string, parser: typeof AxiosHeaders.parseParameters): AxiosHeaderParameters;
   get(headerName: string, parser: RegExp): RegExpExecArray | null;
   get(headerName: string, matcher?: true | AxiosHeaderParser): AxiosHeaderValue;
 
@@ -53,6 +57,8 @@ export class AxiosHeaders {
 
   static from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;
 
+  static parseParameters(value: AxiosHeaderValue): AxiosHeaderParameters;
+
   static accessor(header: string | string[]): AxiosHeaders;
 
   static concat(
@@ -91,6 +97,8 @@ export class AxiosHeaders {
 
   getSetCookie(): string[];
 
+  toString(): string;
+
   [Symbol.iterator](): IterableIterator<[string, AxiosHeaderValue]>;
 }
 
@@ -233,6 +241,13 @@ export enum HttpStatusCode {
   LoopDetected = 508,
   NotExtended = 510,
   NetworkAuthenticationRequired = 511,
+  WebServerReturnsAnUnknownError = 520,
+  WebServerIsDown = 521,
+  ConnectionTimedOut = 522,
+  OriginIsUnreachable = 523,
+  TimeoutOccurred = 524,
+  SslHandshakeFailed = 525,
+  InvalidSslCertificate = 526,
 }
 
 type UppercaseMethod =
@@ -315,6 +330,8 @@ export interface SerializerOptions {
   dots?: boolean;
   metaTokens?: boolean;
   indexes?: boolean | null;
+  maxDepth?: number;
+  Blob?: { new (...args: any[]): any };
 }
 
 // tslint:disable-next-line
@@ -324,13 +341,13 @@ export interface ParamEncoder {
   (value: any, defaultEncoder: (value: any) => any): any;
 }
 
-export interface CustomParamsSerializer {
-  (params: Record<string, any>, options?: ParamsSerializerOptions): string;
+export interface CustomParamsSerializer<P = Record<string, any>> {
+  (params: P, options?: ParamsSerializerOptions<P>): string;
 }
 
-export interface ParamsSerializerOptions extends SerializerOptions {
+export interface ParamsSerializerOptions<P = Record<string, any>> extends SerializerOptions {
   encode?: ParamEncoder;
-  serialize?: CustomParamsSerializer;
+  serialize?: CustomParamsSerializer<P>;
 }
 
 type MaxUploadRate = number;
@@ -367,7 +384,7 @@ export interface LookupAddressEntry {
 
 export type LookupAddress = string | LookupAddressEntry;
 
-export interface AxiosRequestConfig<D = any> {
+export interface AxiosRequestConfig<D = any, P = any> {
   url?: string;
   method?: StringLiteralsOrString<Method>;
   baseURL?: string;
@@ -375,8 +392,10 @@ export interface AxiosRequestConfig<D = any> {
   transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];
   transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];
   headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;
-  params?: any;
-  paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;
+  params?: P;
+  paramsSerializer?:
+    | ParamsSerializerOptions<unknown extends P ? Record<string, any> : P>
+    | CustomParamsSerializer<unknown extends P ? Record<string, any> : P>;
   data?: D;
   timeout?: Milliseconds;
   timeoutErrorMessage?: string;
@@ -444,7 +463,7 @@ export interface AxiosRequestConfig<D = any> {
       ) => Promise<
         [address: LookupAddressEntry | LookupAddressEntry[], family?: AddressFamily] | LookupAddress
       >);
-  withXSRFToken?: boolean | ((config: InternalAxiosRequestConfig) => boolean | undefined);
+  withXSRFToken?: boolean | ((config: InternalAxiosRequestConfig<D, P>) => boolean | undefined);
   parseReviver?: (this: any, key: string, value: any, context?: { source?: string }) => any;
   fetchOptions?: Omit<RequestInit, 'body' | 'headers' | 'method' | 'signal'> | Record<string, any>;
   httpVersion?: 1 | 2;
@@ -457,9 +476,9 @@ export interface AxiosRequestConfig<D = any> {
 }
 
 // Alias
-export type RawAxiosRequestConfig<D = any> = AxiosRequestConfig<D>;
+export type RawAxiosRequestConfig<D = any, P = any> = AxiosRequestConfig<D, P>;
 
-export interface InternalAxiosRequestConfig<D = any> extends AxiosRequestConfig<D> {
+export interface InternalAxiosRequestConfig<D = any, P = any> extends AxiosRequestConfig<D, P> {
   headers: AxiosRequestHeaders;
 }
 
@@ -478,49 +497,52 @@ export interface HeadersDefaults {
   query?: RawAxiosRequestHeaders;
 }
 
-export interface AxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
+export interface AxiosDefaults<D = any, P = any> extends Omit<AxiosRequestConfig<D, P>, 'headers'> {
   headers: HeadersDefaults;
 }
 
-export interface CreateAxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
+export interface CreateAxiosDefaults<D = any, P = any> extends Omit<
+  AxiosRequestConfig<D, P>,
+  'headers'
+> {
   headers?: RawAxiosRequestHeaders | AxiosHeaders | Partial<HeadersDefaults>;
 }
 
-export interface AxiosResponse<T = any, D = any, H = {}> {
+export interface AxiosResponse<T = any, D = any, H = {}, P = any> {
   data: T;
   status: number;
   statusText: string;
   headers: (H & RawAxiosResponseHeaders) | AxiosResponseHeaders;
-  config: InternalAxiosRequestConfig<D>;
+  config: InternalAxiosRequestConfig<D, P>;
   request?: any;
 }
 
-export class AxiosError<T = unknown, D = any> extends Error {
+export class AxiosError<T = unknown, D = any, P = any> extends Error {
   constructor(
     message?: string,
     code?: string,
-    config?: InternalAxiosRequestConfig<D>,
+    config?: InternalAxiosRequestConfig<D, P>,
     request?: any,
-    response?: AxiosResponse<T, D>
+    response?: AxiosResponse<T, D, {}, P>
   );
 
-  config?: InternalAxiosRequestConfig<D>;
+  config?: InternalAxiosRequestConfig<D, P>;
   code?: string;
   request?: any;
-  response?: AxiosResponse<T, D>;
+  response?: AxiosResponse<T, D, {}, P>;
   isAxiosError: boolean;
   status?: number;
   toJSON: () => object;
   cause?: Error;
   event?: BrowserProgressEvent;
-  static from<T = unknown, D = any>(
+  static from<T = unknown, D = any, P = any>(
     error: Error | unknown,
     code?: string,
-    config?: InternalAxiosRequestConfig<D>,
+    config?: InternalAxiosRequestConfig<D, P>,
     request?: any,
-    response?: AxiosResponse<T, D>,
+    response?: AxiosResponse<T, D, {}, P>,
     customProps?: object
-  ): AxiosError<T, D>;
+  ): AxiosError<T, D, P>;
   static readonly ERR_FR_TOO_MANY_REDIRECTS = 'ERR_FR_TOO_MANY_REDIRECTS';
   static readonly ERR_BAD_OPTION_VALUE = 'ERR_BAD_OPTION_VALUE';
   static readonly ERR_BAD_OPTION = 'ERR_BAD_OPTION';
@@ -537,11 +559,21 @@ export class AxiosError<T = unknown, D = any> extends Error {
   static readonly ETIMEDOUT = 'ETIMEDOUT';
 }
 
-export class CanceledError<T> extends AxiosError<T> {
+export class CanceledError<T, D = any, P = any> extends AxiosError<T, D, P> {
+  constructor(message?: string, config?: InternalAxiosRequestConfig<D, P>, request?: any);
   readonly name: 'CanceledError';
+  __CANCEL__?: boolean;
 }
 
-export type AxiosPromise<T = any> = Promise<AxiosResponse<T>>;
+declare const axiosResponseDefault: unique symbol;
+
+type AxiosResponseDefault = typeof axiosResponseDefault;
+
+type AxiosResponseResult<T, R, D, P> = R extends AxiosResponseDefault
+  ? AxiosResponse<T, D, {}, P>
+  : R;
+
+export type AxiosPromise<T = any, D = any, P = any> = Promise<AxiosResponse<T, D, {}, P>>;
 
 export interface CancelStatic {
   new (message?: string): Cancel;
@@ -564,6 +596,9 @@ export interface CancelToken {
   promise: Promise<Cancel>;
   reason?: Cancel;
   throwIfRequested(): void;
+  subscribe(listener: (cancel: Cancel | any) => void): void;
+  unsubscribe(listener: (cancel: Cancel | any) => void): void;
+  toAbortSignal(): AbortSignal;
 }
 
 export interface CancelTokenSource {
@@ -612,63 +647,70 @@ export class Axios {
     response: AxiosInterceptorManager<AxiosResponse>;
   };
   getUri(config?: AxiosRequestConfig): string;
-  request<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
-  get<T = any, R = AxiosResponse<T>, D = any>(
+  request<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    config: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  get<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  delete<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  delete<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  head<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  head<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  options<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  options<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  post<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  post<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
     data?: D,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  put<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  put<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
     data?: D,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  patch<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  patch<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
     data?: D,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  postForm<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  postForm<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
     data?: D,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  putForm<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  putForm<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
     data?: D,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  patchForm<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  patchForm<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
     data?: D,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
-  query<T = any, R = AxiosResponse<T>, D = any>(
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  query<T = any, R = AxiosResponseDefault, D = any, P = any>(
     url: string,
     data?: D,
-    config?: AxiosRequestConfig<D>
-  ): Promise<R>;
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
 }
 
 export interface AxiosInstance extends Axios {
-  <T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
-  <T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
+  <T = any, R = AxiosResponseDefault, D = any, P = any>(
+    config: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  <T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    config?: AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
 
   create(config?: CreateAxiosDefaults): AxiosInstance;
   defaults: Omit<AxiosDefaults, 'headers'> & {
@@ -700,23 +742,25 @@ export function toFormData(
 
 export function formToJSON(form: GenericFormData | GenericHTMLFormElement): object;
 
-export function isAxiosError<T = any, D = any>(payload: any): payload is AxiosError<T, D>;
+export function isAxiosError<T = any, D = any, P = any>(
+  payload: any
+): payload is AxiosError<T, D, P>;
 
 export function spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
 
-export function isCancel<T = any>(value: any): value is CanceledError<T>;
+export function isCancel<T = any, D = any, P = any>(value: any): value is CanceledError<T, D, P>;
 
 export function all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
 
-export function mergeConfig<D = any>(
-  config1: AxiosRequestConfig<D>,
-  config2: AxiosRequestConfig<D>
-): AxiosRequestConfig<D>;
+export function mergeConfig<D = any, P = any>(
+  config1: AxiosRequestConfig<D, P>,
+  config2: AxiosRequestConfig<D, P>
+): AxiosRequestConfig<D, P>;
 
 export function create(config?: CreateAxiosDefaults): AxiosInstance;
 
 export interface AxiosStatic extends AxiosInstance {
-  Cancel: CancelStatic;
+  Cancel: typeof CanceledError;
   CancelToken: CancelTokenStatic;
   Axios: typeof Axios;
   AxiosError: typeof AxiosError;

package/lib/adapters/adapters.js

@@ -107,7 +107,7 @@ function getAdapter(adapters, config) {
 
     throw new AxiosError(
       `There is no suitable adapter to dispatch the request ` + s,
-      'ERR_NOT_SUPPORT'
+      AxiosError.ERR_NOT_SUPPORT
     );
   }
 

package/lib/adapters/fetch.js

@@ -557,7 +557,17 @@ const factory = (env) => {
         const canceledError = composedSignal.reason;
         canceledError.config = config;
         request && (canceledError.request = request);
-        err !== canceledError && (canceledError.cause = err);
+        if (err !== canceledError) {
+          // Non-enumerable to match native Error `cause` semantics so loggers
+          // don't recurse into circular fetch internals (see #7205).
+          Object.defineProperty(canceledError, 'cause', {
+            __proto__: null,
+            value: err,
+            writable: true,
+            enumerable: false,
+            configurable: true,
+          });
+        }
         throw canceledError;
       }
 
@@ -579,18 +589,23 @@ const factory = (env) => {
       }
 
       if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
-        throw Object.assign(
-          new AxiosError(
-            'Network Error',
-            AxiosError.ERR_NETWORK,
-            config,
-            request,
-            err && err.response
-          ),
-          {
-            cause: err.cause || err,
-          }
+        const networkError = new AxiosError(
+          'Network Error',
+          AxiosError.ERR_NETWORK,
+          config,
+          request,
+          err && err.response
         );
+        // Non-enumerable to match native Error `cause` semantics so loggers
+        // don't recurse into circular fetch internals (see #7205).
+        Object.defineProperty(networkError, 'cause', {
+          __proto__: null,
+          value: err.cause || err,
+          writable: true,
+          enumerable: false,
+          configurable: true,
+        });
+        throw networkError;
       }
 
       throw AxiosError.from(err, err && err.code, config, request, err && err.response);

package/lib/adapters/http.js

@@ -19,6 +19,7 @@ import platform from '../platform/index.js';
 import fromDataURI from '../helpers/fromDataURI.js';
 import stream from 'stream';
 import AxiosHeaders from '../core/AxiosHeaders.js';
+import setFormDataHeaders from '../core/setFormDataHeaders.js';
 import AxiosTransformStream from '../helpers/AxiosTransformStream.js';
 import { EventEmitter } from 'events';
 import formDataToStream from '../helpers/formDataToStream.js';
@@ -33,7 +34,7 @@ import {
   progressEventDecorator,
   asyncDecorator,
 } from '../helpers/progressEventReducer.js';
-import estimateDataURLDecodedBytes from '../helpers/estimateDataURLDecodedBytes.js';
+import { estimateDataURLBufferAllocation } from '../helpers/estimateDataURLDecodedBytes.js';
 
 const zlibOptions = {
   flush: zlib.constants.Z_SYNC_FLUSH,
@@ -54,24 +55,12 @@ const isBrotliSupported = utils.isFunction(zlib.createBrotliDecompress);
 const isZstdSupported = utils.isFunction(zlib.createZstdDecompress);
 const ACCEPT_ENCODING = 'gzip, compress, deflate' + (isBrotliSupported ? ', br' : '');
 const ACCEPT_ENCODING_WITH_ZSTD = ACCEPT_ENCODING + (isZstdSupported ? ', zstd' : '');
+const scheduleProgress =
+  typeof process !== 'undefined' && process.nextTick ? process.nextTick.bind(process) : utils.asap;
 
 const { http: httpFollow, https: httpsFollow } = followRedirects;
 
 const isHttps = /https:?/;
-const FORM_DATA_CONTENT_HEADERS = ['content-type', 'content-length'];
-
-function setFormDataHeaders(headers, formHeaders, policy) {
-  if (policy !== 'content-only') {
-    headers.set(formHeaders);
-    return;
-  }
-
-  Object.entries(formHeaders).forEach(([key, val]) => {
-    if (FORM_DATA_CONTENT_HEADERS.includes(key.toLowerCase())) {
-      headers.set(key, val);
-    }
-  });
-}
 
 // Symbols used to bind a single 'error' listener to a pooled socket and track
 // the request currently owning that socket across keep-alive reuse (issue #10780).
@@ -89,6 +78,53 @@ const kAxiosInstalledTunnel = Symbol('axios.http.installedTunnel');
 // so unbounded growth is not a concern in practice.
 const tunnelingAgentCache = new Map();
 const tunnelingAgentCacheUser = new WeakMap();
+// Minimum minor versions where Node's HTTP Agent supports native proxyEnv
+// handling. Checking the selected agent below also covers startup modes such
+// as NODE_OPTIONS=--use-env-proxy and --no-use-env-proxy precedence.
+const NODE_NATIVE_ENV_PROXY_SUPPORT = {
+  22: 21,
+  24: 5,
+};
+
+function isNodeNativeEnvProxySupported(nodeVersion = process.versions && process.versions.node) {
+  if (!nodeVersion) {
+    return false;
+  }
+
+  const [major, minor] = nodeVersion.split('.').map((part) => Number(part));
+
+  if (!Number.isInteger(major) || !Number.isInteger(minor)) {
+    return false;
+  }
+
+  if (major > 24) {
+    return true;
+  }
+
+  return (
+    NODE_NATIVE_ENV_PROXY_SUPPORT[major] != null && minor >= NODE_NATIVE_ENV_PROXY_SUPPORT[major]
+  );
+}
+
+function isNodeEnvProxyEnabled(agent, nodeVersion = process.versions && process.versions.node) {
+  if (!isNodeNativeEnvProxySupported(nodeVersion)) {
+    return false;
+  }
+
+  const agentOptions = agent && agent.options;
+
+  return Boolean(
+    agentOptions &&
+      utils.hasOwnProp(agentOptions, 'proxyEnv') &&
+      agentOptions.proxyEnv != null
+  );
+}
+
+function getProxyEnvAgent(options, configHttpAgent, configHttpsAgent) {
+  return isHttps.test(options.protocol)
+    ? (configHttpsAgent || https.globalAgent)
+    : (configHttpAgent || http.globalAgent);
+}
 
 function getTunnelingAgent(agentOptions, userHttpsAgent) {
   const key =
@@ -210,9 +246,10 @@ function isSameOriginRedirect(redirectOptions, requestDetails) {
  *
  * @returns {http.ClientRequestArgs}
  */
-function setProxy(options, configProxy, location, isRedirect, configHttpsAgent) {
+function setProxy(options, configProxy, location, isRedirect, configHttpsAgent, configHttpAgent) {
   let proxy = configProxy;
-  if (!proxy && proxy !== false) {
+  const proxyEnvAgent = getProxyEnvAgent(options, configHttpAgent, configHttpsAgent);
+  if (!proxy && proxy !== false && !isNodeEnvProxyEnabled(proxyEnvAgent)) {
     const proxyUrl = getProxyForUrl(location);
     if (proxyUrl) {
       if (!shouldBypassProxy(location)) {
@@ -363,7 +400,14 @@ function setProxy(options, configProxy, location, isRedirect, configHttpsAgent)
   options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
     // Configure proxy for redirected request, passing the original config proxy to apply
     // the exact same logic as if the redirected request was performed by axios directly.
-    setProxy(redirectOptions, configProxy, redirectOptions.href, true, configHttpsAgent);
+    setProxy(
+      redirectOptions,
+      configProxy,
+      redirectOptions.href,
+      true,
+      configHttpsAgent,
+      configHttpAgent
+    );
   };
 }
 
@@ -475,10 +519,12 @@ export default isHttpAdapterSupported &&
       let httpVersion = own('httpVersion');
       if (httpVersion === undefined) httpVersion = 1;
       let http2Options = own('http2Options');
-      const responseType = own('responseType');
-      const responseEncoding = own('responseEncoding');
       const httpAgent = own('httpAgent');
       const httpsAgent = own('httpsAgent');
+      const configProxy = own('proxy');
+      const responseType = own('responseType');
+      const responseEncoding = own('responseEncoding');
+      const socketPath = own('socketPath');
       const method = own('method').toUpperCase();
       const maxRedirects = own('maxRedirects');
       const maxBodyLength = own('maxBodyLength');
@@ -603,7 +649,14 @@ export default isHttpAdapterSupported &&
 
       // Parse url
       const fullPath = buildFullPath(own('baseURL'), own('url'), own('allowAbsoluteUrls'), config);
-      const parsed = new URL(fullPath, platform.hasBrowserEnv ? platform.origin : undefined);
+      // Unix-socket requests (own socketPath) commonly pass a path-only url
+      // like '/foo'; supply a synthetic base so new URL() can still parse it.
+      // Use the own-property value (not config.socketPath) so a polluted
+      // prototype cannot influence URL base selection.
+      const urlBase = socketPath
+        ? 'http://localhost'
+        : (platform.hasBrowserEnv ? platform.origin : undefined);
+      const parsed = new URL(fullPath, urlBase);
       const protocol = parsed.protocol || supportedProtocols[0];
 
       if (protocol === 'data:') {
@@ -611,7 +664,7 @@ export default isHttpAdapterSupported &&
         if (maxContentLength > -1) {
           // Use the exact string passed to fromDataURI (the configured url); fall back to fullPath if needed.
           const dataUrl = String(own('url') || fullPath || '');
-          const estimated = estimateDataURLDecodedBytes(dataUrl);
+          const estimated = estimateDataURLBufferAllocation(dataUrl);
 
           if (estimated > maxContentLength) {
             return reject(
@@ -778,7 +831,7 @@ export default isHttpAdapterSupported &&
               data,
               progressEventDecorator(
                 contentLength,
-                progressEventReducer(asyncDecorator(onUploadProgress), false, 3)
+                progressEventReducer(asyncDecorator(onUploadProgress, scheduleProgress), false, 3)
               )
             )
           );
@@ -810,11 +863,12 @@ export default isHttpAdapterSupported &&
           own('paramsSerializer')
         ).replace(/^\?/, '');
       } catch (err) {
-        const customErr = new Error(err.message);
-        customErr.config = config;
-        customErr.url = own('url');
-        customErr.exists = true;
-        return reject(customErr);
+        return reject(
+          AxiosError.from(err, AxiosError.ERR_BAD_REQUEST, config, null, null, {
+            url: own('url'),
+            exists: true
+          })
+        );
       }
 
       headers.set(
@@ -842,7 +896,6 @@ export default isHttpAdapterSupported &&
       // cacheable-lookup integration hotfix
       !utils.isUndefined(lookup) && (options.lookup = lookup);
 
-      const socketPath = own('socketPath');
       if (socketPath) {
         if (typeof socketPath !== 'string') {
           return reject(
@@ -880,10 +933,11 @@ export default isHttpAdapterSupported &&
         options.port = parsed.port;
         setProxy(
           options,
-          own('proxy'),
+          configProxy,
           protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path,
           false,
-          httpsAgent
+          httpsAgent,
+          httpAgent
         );
       }
       let transport;
@@ -979,10 +1033,12 @@ export default isHttpAdapterSupported &&
         }
       }
 
+      // Set an explicit maxBodyLength option for transports that inspect it.
+      // When maxBodyLength is -1 (default/unlimited), use Infinity so
+      // follow-redirects does not fall back to its own 10MB default.
       if (maxBodyLength > -1) {
         options.maxBodyLength = maxBodyLength;
       } else {
-        // follow-redirects does not skip comparison, so it should always succeed for axios -1 unlimited
         options.maxBodyLength = Infinity;
       }
 
@@ -1013,7 +1069,7 @@ export default isHttpAdapterSupported &&
                 transformStream,
                 progressEventDecorator(
                   responseLength,
-                  progressEventReducer(asyncDecorator(onDownloadProgress), true, 3)
+                  progressEventReducer(asyncDecorator(onDownloadProgress, scheduleProgress), true, 3)
                 )
               )
             );
@@ -1205,7 +1261,11 @@ export default isHttpAdapterSupported &&
 
       req.on('socket', function handleRequestSocket(socket) {
         // default interval of sending ack packet is 1 minute
-        socket.setKeepAlive(true, 1000 * 60);
+        // proxy agents (e.g. agent-base) may return a generic Duplex stream
+        // that doesn't have setKeepAlive, so guard before calling
+        if (typeof socket.setKeepAlive === 'function') {
+          socket.setKeepAlive(true, 1000 * 60);
+        }
 
         // Install a single 'error' listener per socket (not per request) to avoid
         // accumulating listeners on pooled keep-alive sockets that get reassigned
@@ -1342,4 +1402,5 @@ export default isHttpAdapterSupported &&
   };
 
 export const __setProxy = setProxy;
+export const __isNodeEnvProxyEnabled = isNodeEnvProxyEnabled;
 export const __isSameOriginRedirect = isSameOriginRedirect;