rezo 1.0.2 → 1.0.4

package/dist/adapters/entries/xhr.js

@@ -1 +1,29 @@
-export { executeRequest } from '../xhr.js';
+import { executeRequest } from '../xhr.js';
+import { setGlobalAdapter, createRezoInstance, Rezo } from '../../core/rezo.js';
+import { RezoError, RezoErrorCode } from '../../errors/rezo-error.js';
+import { RezoHeaders } from '../../utils/headers.js';
+import { RezoFormData } from '../../utils/form-data.js';
+import { RezoCookieJar } from '../../utils/cookies.js';
+import { createDefaultHooks, mergeHooks } from '../../core/hooks.js';
+import packageJson from "../../../package.json" with { type: 'json' };
+
+export { Rezo };
+export { RezoError };
+export { RezoErrorCode };
+export { RezoHeaders };
+export { RezoFormData };
+export { RezoCookieJar };
+export { createDefaultHooks };
+export { mergeHooks };
+export const isRezoError = RezoError.isRezoError;
+export const Cancel = RezoError;
+export const CancelToken = AbortController;
+export const isCancel = (error) => {
+  return error instanceof RezoError && error.code === "ECONNABORTED";
+};
+export const all = Promise.all.bind(Promise);
+export const spread = (callback) => (array) => callback(...array);
+export const VERSION = packageJson.version;
+setGlobalAdapter(executeRequest);
+const rezo = createRezoInstance(executeRequest);
+export default rezo;

package/dist/adapters/fetch.cjs

@@ -248,29 +248,33 @@ async function executeRequest(options, defaultOptions, jar) {
     const url = typeof fetchOptions.url === "string" ? fetchOptions.url : fetchOptions.url?.toString() || "";
     uploadResponse = new UploadResponse(url);
   }
-  const res = executeFetchRequest(fetchOptions, mainConfig, options, perform, streamResponse, downloadResponse, uploadResponse);
-  if (streamResponse) {
-    return streamResponse;
-  } else if (downloadResponse) {
-    return downloadResponse;
-  } else if (uploadResponse) {
-    return uploadResponse;
-  }
-  const response = await res;
-  if (cache && !isStream && !isDownload && !isUpload) {
-    if (response.status === 304 && cachedEntry) {
-      const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
-      const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
-      if (updatedCached) {
-        return buildCachedRezoResponse(updatedCached, mainConfig);
-      }
-      return buildCachedRezoResponse(cachedEntry, mainConfig);
+  try {
+    const res = executeFetchRequest(fetchOptions, mainConfig, options, perform, streamResponse, downloadResponse, uploadResponse);
+    if (streamResponse) {
+      return streamResponse;
+    } else if (downloadResponse) {
+      return downloadResponse;
+    } else if (uploadResponse) {
+      return uploadResponse;
     }
-    if (response.status >= 200 && response.status < 300) {
-      cache.set(method, requestUrl, response, requestHeaders);
+    const response = await res;
+    if (cache && !isStream && !isDownload && !isUpload) {
+      if (response.status === 304 && cachedEntry) {
+        const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
+        const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
+        if (updatedCached) {
+          return buildCachedRezoResponse(updatedCached, mainConfig);
+        }
+        return buildCachedRezoResponse(cachedEntry, mainConfig);
+      }
+      if (response.status >= 200 && response.status < 300) {
+        cache.set(method, requestUrl, response, requestHeaders);
+      }
     }
+    return response;
+  } catch (error) {
+    throw error;
   }
-  return response;
 }
 async function executeFetchRequest(fetchOptions, config, options, perform, streamResult, downloadResult, uploadResult) {
   let requestCount = 0;

package/dist/adapters/fetch.js

@@ -248,29 +248,33 @@ export async function executeRequest(options, defaultOptions, jar) {
     const url = typeof fetchOptions.url === "string" ? fetchOptions.url : fetchOptions.url?.toString() || "";
     uploadResponse = new UploadResponse(url);
   }
-  const res = executeFetchRequest(fetchOptions, mainConfig, options, perform, streamResponse, downloadResponse, uploadResponse);
-  if (streamResponse) {
-    return streamResponse;
-  } else if (downloadResponse) {
-    return downloadResponse;
-  } else if (uploadResponse) {
-    return uploadResponse;
-  }
-  const response = await res;
-  if (cache && !isStream && !isDownload && !isUpload) {
-    if (response.status === 304 && cachedEntry) {
-      const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
-      const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
-      if (updatedCached) {
-        return buildCachedRezoResponse(updatedCached, mainConfig);
-      }
-      return buildCachedRezoResponse(cachedEntry, mainConfig);
+  try {
+    const res = executeFetchRequest(fetchOptions, mainConfig, options, perform, streamResponse, downloadResponse, uploadResponse);
+    if (streamResponse) {
+      return streamResponse;
+    } else if (downloadResponse) {
+      return downloadResponse;
+    } else if (uploadResponse) {
+      return uploadResponse;
     }
-    if (response.status >= 200 && response.status < 300) {
-      cache.set(method, requestUrl, response, requestHeaders);
+    const response = await res;
+    if (cache && !isStream && !isDownload && !isUpload) {
+      if (response.status === 304 && cachedEntry) {
+        const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
+        const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
+        if (updatedCached) {
+          return buildCachedRezoResponse(updatedCached, mainConfig);
+        }
+        return buildCachedRezoResponse(cachedEntry, mainConfig);
+      }
+      if (response.status >= 200 && response.status < 300) {
+        cache.set(method, requestUrl, response, requestHeaders);
+      }
     }
+    return response;
+  } catch (error) {
+    throw error;
   }
-  return response;
 }
 async function executeFetchRequest(fetchOptions, config, options, perform, streamResult, downloadResult, uploadResult) {
   let requestCount = 0;

package/dist/adapters/http.cjs

@@ -96,10 +96,26 @@ async function executeRequest(options, defaultOptions, jar) {
   if (!options.responseType) {
     options.responseType = "auto";
   }
-  const d_options = await getDefaultConfig(defaultOptions);
+  const d_options = await getDefaultConfig(defaultOptions, defaultOptions._proxyManager);
   const config = prepareHTTPOptions(options, jar, { defaultOptions: d_options });
   let mainConfig = config.config;
+  const { proxyManager } = config;
   const perform = new RezoPerformance;
+  let selectedProxy = null;
+  if (proxyManager) {
+    const requestUrl = typeof config.fetchOptions.url === "string" ? config.fetchOptions.url : config.fetchOptions.url?.toString() || "";
+    selectedProxy = proxyManager.next(requestUrl);
+    if (selectedProxy) {
+      config.fetchOptions.proxy = {
+        protocol: selectedProxy.protocol,
+        host: selectedProxy.host,
+        port: selectedProxy.port,
+        auth: selectedProxy.auth
+      };
+    } else if (proxyManager.config.failWithoutProxy) {
+      throw new RezoError("No proxy available: All proxies exhausted or URL did not match whitelist/blacklist", mainConfig, "UNQ_NO_PROXY_AVAILABLE", config.fetchOptions);
+    }
+  }
   const cacheOption = options.cache;
   const method = (options.method || "GET").toUpperCase();
   const requestUrl = typeof config.fetchOptions.url === "string" ? config.fetchOptions.url : config.fetchOptions.url?.toString() || "";
@@ -153,29 +169,63 @@ async function executeRequest(options, defaultOptions, jar) {
     const url = typeof config.fetchOptions.url === "string" ? config.fetchOptions.url : config.fetchOptions.url.toString();
     uploadResponse = new UploadResponse(url, fileName);
   }
-  const res = executeHttp1Request(config.fetchOptions, mainConfig, config.options, perform, d_options.fs, streamResponse, downloadResponse, uploadResponse);
-  if (streamResponse) {
-    return streamResponse;
-  } else if (downloadResponse) {
-    return downloadResponse;
-  } else if (uploadResponse) {
-    return uploadResponse;
+  if (proxyManager && selectedProxy) {
+    if (streamResponse) {
+      streamResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      streamResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    } else if (downloadResponse) {
+      downloadResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      downloadResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    } else if (uploadResponse) {
+      uploadResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      uploadResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    }
   }
-  const response = await res;
-  if (cache && !isStream && !isDownload && !isUpload) {
-    if (response.status === 304 && cachedEntry) {
-      const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
-      const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
-      if (updatedCached) {
-        return buildCachedRezoResponse(updatedCached, mainConfig);
+  try {
+    const res = executeHttp1Request(config.fetchOptions, mainConfig, config.options, perform, d_options.fs, streamResponse, downloadResponse, uploadResponse);
+    if (streamResponse) {
+      return streamResponse;
+    } else if (downloadResponse) {
+      return downloadResponse;
+    } else if (uploadResponse) {
+      return uploadResponse;
+    }
+    const response = await res;
+    if (proxyManager && selectedProxy) {
+      proxyManager.reportSuccess(selectedProxy);
+    }
+    if (cache && !isStream && !isDownload && !isUpload) {
+      if (response.status === 304 && cachedEntry) {
+        const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
+        const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
+        if (updatedCached) {
+          return buildCachedRezoResponse(updatedCached, mainConfig);
+        }
+        return buildCachedRezoResponse(cachedEntry, mainConfig);
+      }
+      if (response.status >= 200 && response.status < 300) {
+        cache.set(method, requestUrl, response, requestHeaders);
       }
-      return buildCachedRezoResponse(cachedEntry, mainConfig);
     }
-    if (response.status >= 200 && response.status < 300) {
-      cache.set(method, requestUrl, response, requestHeaders);
+    return response;
+  } catch (error) {
+    if (proxyManager && selectedProxy) {
+      proxyManager.reportFailure(selectedProxy, error);
     }
+    throw error;
   }
-  return response;
 }
 async function executeHttp1Request(fetchOptions, config, options, perform, fs, streamResult, downloadResult, uploadResult) {
   let requestCount = 0;

package/dist/adapters/http.js

@@ -96,10 +96,26 @@ export async function executeRequest(options, defaultOptions, jar) {
   if (!options.responseType) {
     options.responseType = "auto";
   }
-  const d_options = await getDefaultConfig(defaultOptions);
+  const d_options = await getDefaultConfig(defaultOptions, defaultOptions._proxyManager);
   const config = prepareHTTPOptions(options, jar, { defaultOptions: d_options });
   let mainConfig = config.config;
+  const { proxyManager } = config;
   const perform = new RezoPerformance;
+  let selectedProxy = null;
+  if (proxyManager) {
+    const requestUrl = typeof config.fetchOptions.url === "string" ? config.fetchOptions.url : config.fetchOptions.url?.toString() || "";
+    selectedProxy = proxyManager.next(requestUrl);
+    if (selectedProxy) {
+      config.fetchOptions.proxy = {
+        protocol: selectedProxy.protocol,
+        host: selectedProxy.host,
+        port: selectedProxy.port,
+        auth: selectedProxy.auth
+      };
+    } else if (proxyManager.config.failWithoutProxy) {
+      throw new RezoError("No proxy available: All proxies exhausted or URL did not match whitelist/blacklist", mainConfig, "UNQ_NO_PROXY_AVAILABLE", config.fetchOptions);
+    }
+  }
   const cacheOption = options.cache;
   const method = (options.method || "GET").toUpperCase();
   const requestUrl = typeof config.fetchOptions.url === "string" ? config.fetchOptions.url : config.fetchOptions.url?.toString() || "";
@@ -153,29 +169,63 @@ export async function executeRequest(options, defaultOptions, jar) {
     const url = typeof config.fetchOptions.url === "string" ? config.fetchOptions.url : config.fetchOptions.url.toString();
     uploadResponse = new UploadResponse(url, fileName);
   }
-  const res = executeHttp1Request(config.fetchOptions, mainConfig, config.options, perform, d_options.fs, streamResponse, downloadResponse, uploadResponse);
-  if (streamResponse) {
-    return streamResponse;
-  } else if (downloadResponse) {
-    return downloadResponse;
-  } else if (uploadResponse) {
-    return uploadResponse;
+  if (proxyManager && selectedProxy) {
+    if (streamResponse) {
+      streamResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      streamResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    } else if (downloadResponse) {
+      downloadResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      downloadResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    } else if (uploadResponse) {
+      uploadResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      uploadResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    }
   }
-  const response = await res;
-  if (cache && !isStream && !isDownload && !isUpload) {
-    if (response.status === 304 && cachedEntry) {
-      const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
-      const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
-      if (updatedCached) {
-        return buildCachedRezoResponse(updatedCached, mainConfig);
+  try {
+    const res = executeHttp1Request(config.fetchOptions, mainConfig, config.options, perform, d_options.fs, streamResponse, downloadResponse, uploadResponse);
+    if (streamResponse) {
+      return streamResponse;
+    } else if (downloadResponse) {
+      return downloadResponse;
+    } else if (uploadResponse) {
+      return uploadResponse;
+    }
+    const response = await res;
+    if (proxyManager && selectedProxy) {
+      proxyManager.reportSuccess(selectedProxy);
+    }
+    if (cache && !isStream && !isDownload && !isUpload) {
+      if (response.status === 304 && cachedEntry) {
+        const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
+        const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
+        if (updatedCached) {
+          return buildCachedRezoResponse(updatedCached, mainConfig);
+        }
+        return buildCachedRezoResponse(cachedEntry, mainConfig);
+      }
+      if (response.status >= 200 && response.status < 300) {
+        cache.set(method, requestUrl, response, requestHeaders);
       }
-      return buildCachedRezoResponse(cachedEntry, mainConfig);
     }
-    if (response.status >= 200 && response.status < 300) {
-      cache.set(method, requestUrl, response, requestHeaders);
+    return response;
+  } catch (error) {
+    if (proxyManager && selectedProxy) {
+      proxyManager.reportFailure(selectedProxy, error);
     }
+    throw error;
   }
-  return response;
 }
 async function executeHttp1Request(fetchOptions, config, options, perform, fs, streamResult, downloadResult, uploadResult) {
   let requestCount = 0;

package/dist/adapters/http2.cjs

@@ -308,11 +308,27 @@ async function executeRequest(options, defaultOptions, jar) {
   if (!options.responseType) {
     options.responseType = "auto";
   }
-  const d_options = await getDefaultConfig(defaultOptions);
+  const d_options = await getDefaultConfig(defaultOptions, defaultOptions._proxyManager);
   const configResult = prepareHTTPOptions(options, jar, { defaultOptions: d_options });
   let mainConfig = configResult.config;
   const fetchOptions = configResult.fetchOptions;
+  const { proxyManager } = configResult;
   const perform = new RezoPerformance;
+  let selectedProxy = null;
+  if (proxyManager) {
+    const requestUrl = typeof fetchOptions.url === "string" ? fetchOptions.url : fetchOptions.url?.toString() || "";
+    selectedProxy = proxyManager.next(requestUrl);
+    if (selectedProxy) {
+      fetchOptions.proxy = {
+        protocol: selectedProxy.protocol,
+        host: selectedProxy.host,
+        port: selectedProxy.port,
+        auth: selectedProxy.auth
+      };
+    } else if (proxyManager.config.failWithoutProxy) {
+      throw new RezoError("No proxy available: All proxies exhausted or URL did not match whitelist/blacklist", mainConfig, "UNQ_NO_PROXY_AVAILABLE", fetchOptions);
+    }
+  }
   const cacheOption = options.cache;
   const method = (options.method || "GET").toUpperCase();
   const requestUrl = typeof fetchOptions.url === "string" ? fetchOptions.url : fetchOptions.url?.toString() || "";
@@ -368,29 +384,63 @@ async function executeRequest(options, defaultOptions, jar) {
     const url = typeof fetchOptions.url === "string" ? fetchOptions.url : fetchOptions.url?.toString() || "";
     uploadResponse = new UploadResponse(url);
   }
-  const res = executeHttp2Request(fetchOptions, mainConfig, options, perform, fs, streamResponse, downloadResponse, uploadResponse);
-  if (streamResponse) {
-    return streamResponse;
-  } else if (downloadResponse) {
-    return downloadResponse;
-  } else if (uploadResponse) {
-    return uploadResponse;
+  if (proxyManager && selectedProxy) {
+    if (streamResponse) {
+      streamResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      streamResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    } else if (downloadResponse) {
+      downloadResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      downloadResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    } else if (uploadResponse) {
+      uploadResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      uploadResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    }
   }
-  const response = await res;
-  if (cache && !isStream && !isDownload && !isUpload) {
-    if (response.status === 304 && cachedEntry) {
-      const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
-      const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
-      if (updatedCached) {
-        return buildCachedRezoResponse(updatedCached, mainConfig);
+  try {
+    const res = executeHttp2Request(fetchOptions, mainConfig, options, perform, fs, streamResponse, downloadResponse, uploadResponse);
+    if (streamResponse) {
+      return streamResponse;
+    } else if (downloadResponse) {
+      return downloadResponse;
+    } else if (uploadResponse) {
+      return uploadResponse;
+    }
+    const response = await res;
+    if (proxyManager && selectedProxy) {
+      proxyManager.reportSuccess(selectedProxy);
+    }
+    if (cache && !isStream && !isDownload && !isUpload) {
+      if (response.status === 304 && cachedEntry) {
+        const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
+        const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
+        if (updatedCached) {
+          return buildCachedRezoResponse(updatedCached, mainConfig);
+        }
+        return buildCachedRezoResponse(cachedEntry, mainConfig);
+      }
+      if (response.status >= 200 && response.status < 300) {
+        cache.set(method, requestUrl, response, requestHeaders);
       }
-      return buildCachedRezoResponse(cachedEntry, mainConfig);
     }
-    if (response.status >= 200 && response.status < 300) {
-      cache.set(method, requestUrl, response, requestHeaders);
+    return response;
+  } catch (error) {
+    if (proxyManager && selectedProxy) {
+      proxyManager.reportFailure(selectedProxy, error);
     }
+    throw error;
   }
-  return response;
 }
 async function executeHttp2Request(fetchOptions, config, options, perform, fs, streamResult, downloadResult, uploadResult) {
   let requestCount = 0;

package/dist/adapters/http2.js

@@ -308,11 +308,27 @@ export async function executeRequest(options, defaultOptions, jar) {
   if (!options.responseType) {
     options.responseType = "auto";
   }
-  const d_options = await getDefaultConfig(defaultOptions);
+  const d_options = await getDefaultConfig(defaultOptions, defaultOptions._proxyManager);
   const configResult = prepareHTTPOptions(options, jar, { defaultOptions: d_options });
   let mainConfig = configResult.config;
   const fetchOptions = configResult.fetchOptions;
+  const { proxyManager } = configResult;
   const perform = new RezoPerformance;
+  let selectedProxy = null;
+  if (proxyManager) {
+    const requestUrl = typeof fetchOptions.url === "string" ? fetchOptions.url : fetchOptions.url?.toString() || "";
+    selectedProxy = proxyManager.next(requestUrl);
+    if (selectedProxy) {
+      fetchOptions.proxy = {
+        protocol: selectedProxy.protocol,
+        host: selectedProxy.host,
+        port: selectedProxy.port,
+        auth: selectedProxy.auth
+      };
+    } else if (proxyManager.config.failWithoutProxy) {
+      throw new RezoError("No proxy available: All proxies exhausted or URL did not match whitelist/blacklist", mainConfig, "UNQ_NO_PROXY_AVAILABLE", fetchOptions);
+    }
+  }
   const cacheOption = options.cache;
   const method = (options.method || "GET").toUpperCase();
   const requestUrl = typeof fetchOptions.url === "string" ? fetchOptions.url : fetchOptions.url?.toString() || "";
@@ -368,29 +384,63 @@ export async function executeRequest(options, defaultOptions, jar) {
     const url = typeof fetchOptions.url === "string" ? fetchOptions.url : fetchOptions.url?.toString() || "";
     uploadResponse = new UploadResponse(url);
   }
-  const res = executeHttp2Request(fetchOptions, mainConfig, options, perform, fs, streamResponse, downloadResponse, uploadResponse);
-  if (streamResponse) {
-    return streamResponse;
-  } else if (downloadResponse) {
-    return downloadResponse;
-  } else if (uploadResponse) {
-    return uploadResponse;
+  if (proxyManager && selectedProxy) {
+    if (streamResponse) {
+      streamResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      streamResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    } else if (downloadResponse) {
+      downloadResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      downloadResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    } else if (uploadResponse) {
+      uploadResponse.on("finish", () => {
+        proxyManager.reportSuccess(selectedProxy);
+      });
+      uploadResponse.on("error", (err) => {
+        proxyManager.reportFailure(selectedProxy, err);
+      });
+    }
   }
-  const response = await res;
-  if (cache && !isStream && !isDownload && !isUpload) {
-    if (response.status === 304 && cachedEntry) {
-      const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
-      const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
-      if (updatedCached) {
-        return buildCachedRezoResponse(updatedCached, mainConfig);
+  try {
+    const res = executeHttp2Request(fetchOptions, mainConfig, options, perform, fs, streamResponse, downloadResponse, uploadResponse);
+    if (streamResponse) {
+      return streamResponse;
+    } else if (downloadResponse) {
+      return downloadResponse;
+    } else if (uploadResponse) {
+      return uploadResponse;
+    }
+    const response = await res;
+    if (proxyManager && selectedProxy) {
+      proxyManager.reportSuccess(selectedProxy);
+    }
+    if (cache && !isStream && !isDownload && !isUpload) {
+      if (response.status === 304 && cachedEntry) {
+        const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
+        const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
+        if (updatedCached) {
+          return buildCachedRezoResponse(updatedCached, mainConfig);
+        }
+        return buildCachedRezoResponse(cachedEntry, mainConfig);
+      }
+      if (response.status >= 200 && response.status < 300) {
+        cache.set(method, requestUrl, response, requestHeaders);
       }
-      return buildCachedRezoResponse(cachedEntry, mainConfig);
     }
-    if (response.status >= 200 && response.status < 300) {
-      cache.set(method, requestUrl, response, requestHeaders);
+    return response;
+  } catch (error) {
+    if (proxyManager && selectedProxy) {
+      proxyManager.reportFailure(selectedProxy, error);
     }
+    throw error;
   }
-  return response;
 }
 async function executeHttp2Request(fetchOptions, config, options, perform, fs, streamResult, downloadResult, uploadResult) {
   let requestCount = 0;

package/dist/adapters/index.cjs

@@ -1,6 +1,6 @@
-const _mod_3xqpwj = require('./picker.cjs');
-exports.detectRuntime = _mod_3xqpwj.detectRuntime;
-exports.getAdapterCapabilities = _mod_3xqpwj.getAdapterCapabilities;
-exports.buildAdapterContext = _mod_3xqpwj.buildAdapterContext;
-exports.getAvailableAdapters = _mod_3xqpwj.getAvailableAdapters;
-exports.selectAdapter = _mod_3xqpwj.selectAdapter;;
+const _mod_y2qidi = require('./picker.cjs');
+exports.detectRuntime = _mod_y2qidi.detectRuntime;
+exports.getAdapterCapabilities = _mod_y2qidi.getAdapterCapabilities;
+exports.buildAdapterContext = _mod_y2qidi.buildAdapterContext;
+exports.getAvailableAdapters = _mod_y2qidi.getAvailableAdapters;
+exports.selectAdapter = _mod_y2qidi.selectAdapter;;

package/dist/cache/index.cjs

@@ -1,13 +1,13 @@
-const _mod_dxws8j = require('./lru-cache.cjs');
-exports.LRUCache = _mod_dxws8j.LRUCache;;
-const _mod_hons1h = require('./dns-cache.cjs');
-exports.DNSCache = _mod_hons1h.DNSCache;
-exports.getGlobalDNSCache = _mod_hons1h.getGlobalDNSCache;
-exports.resetGlobalDNSCache = _mod_hons1h.resetGlobalDNSCache;;
-const _mod_99mq9u = require('./response-cache.cjs');
-exports.ResponseCache = _mod_99mq9u.ResponseCache;
-exports.normalizeResponseCacheConfig = _mod_99mq9u.normalizeResponseCacheConfig;;
-const _mod_pz0bcx = require('./file-cacher.cjs');
-exports.FileCacher = _mod_pz0bcx.FileCacher;;
-const _mod_kc26ws = require('./url-store.cjs');
-exports.UrlStore = _mod_kc26ws.UrlStore;;
+const _mod_hwn1pb = require('./lru-cache.cjs');
+exports.LRUCache = _mod_hwn1pb.LRUCache;;
+const _mod_v5202w = require('./dns-cache.cjs');
+exports.DNSCache = _mod_v5202w.DNSCache;
+exports.getGlobalDNSCache = _mod_v5202w.getGlobalDNSCache;
+exports.resetGlobalDNSCache = _mod_v5202w.resetGlobalDNSCache;;
+const _mod_j87jnr = require('./response-cache.cjs');
+exports.ResponseCache = _mod_j87jnr.ResponseCache;
+exports.normalizeResponseCacheConfig = _mod_j87jnr.normalizeResponseCacheConfig;;
+const _mod_flnkd0 = require('./file-cacher.cjs');
+exports.FileCacher = _mod_flnkd0.FileCacher;;
+const _mod_jkccmq = require('./url-store.cjs');
+exports.UrlStore = _mod_jkccmq.UrlStore;;