rezo 1.0.11 → 1.0.12

package/dist/index.cjs

@@ -1,27 +1,27 @@
-const _mod_ivdy34 = require('./core/rezo.cjs');
-exports.Rezo = _mod_ivdy34.Rezo;
-exports.createRezoInstance = _mod_ivdy34.createRezoInstance;
-exports.createDefaultInstance = _mod_ivdy34.createDefaultInstance;;
-const _mod_eleqc6 = require('./errors/rezo-error.cjs');
-exports.RezoError = _mod_eleqc6.RezoError;
-exports.RezoErrorCode = _mod_eleqc6.RezoErrorCode;;
-const _mod_s3mojl = require('./utils/headers.cjs');
-exports.RezoHeaders = _mod_s3mojl.RezoHeaders;;
-const _mod_ltzvhk = require('./utils/form-data.cjs');
-exports.RezoFormData = _mod_ltzvhk.RezoFormData;;
-const _mod_9b4i5y = require('./utils/cookies.cjs');
-exports.RezoCookieJar = _mod_9b4i5y.RezoCookieJar;
-exports.Cookie = _mod_9b4i5y.Cookie;;
-const _mod_ip126y = require('./core/hooks.cjs');
-exports.createDefaultHooks = _mod_ip126y.createDefaultHooks;
-exports.mergeHooks = _mod_ip126y.mergeHooks;;
-const _mod_zptoz7 = require('./proxy/manager.cjs');
-exports.ProxyManager = _mod_zptoz7.ProxyManager;;
-const _mod_qvzoi6 = require('./queue/index.cjs');
-exports.RezoQueue = _mod_qvzoi6.RezoQueue;
-exports.HttpQueue = _mod_qvzoi6.HttpQueue;
-exports.Priority = _mod_qvzoi6.Priority;
-exports.HttpMethodPriority = _mod_qvzoi6.HttpMethodPriority;;
+const _mod_jr843j = require('./core/rezo.cjs');
+exports.Rezo = _mod_jr843j.Rezo;
+exports.createRezoInstance = _mod_jr843j.createRezoInstance;
+exports.createDefaultInstance = _mod_jr843j.createDefaultInstance;;
+const _mod_tk44ak = require('./errors/rezo-error.cjs');
+exports.RezoError = _mod_tk44ak.RezoError;
+exports.RezoErrorCode = _mod_tk44ak.RezoErrorCode;;
+const _mod_n1xwl0 = require('./utils/headers.cjs');
+exports.RezoHeaders = _mod_n1xwl0.RezoHeaders;;
+const _mod_ci344r = require('./utils/form-data.cjs');
+exports.RezoFormData = _mod_ci344r.RezoFormData;;
+const _mod_611jzw = require('./utils/cookies.cjs');
+exports.RezoCookieJar = _mod_611jzw.RezoCookieJar;
+exports.Cookie = _mod_611jzw.Cookie;;
+const _mod_7h5jew = require('./core/hooks.cjs');
+exports.createDefaultHooks = _mod_7h5jew.createDefaultHooks;
+exports.mergeHooks = _mod_7h5jew.mergeHooks;;
+const _mod_0rf8qu = require('./proxy/manager.cjs');
+exports.ProxyManager = _mod_0rf8qu.ProxyManager;;
+const _mod_ho3aaq = require('./queue/index.cjs');
+exports.RezoQueue = _mod_ho3aaq.RezoQueue;
+exports.HttpQueue = _mod_ho3aaq.HttpQueue;
+exports.Priority = _mod_ho3aaq.Priority;
+exports.HttpMethodPriority = _mod_ho3aaq.HttpMethodPriority;;
 const { RezoError } = require('./errors/rezo-error.cjs');
 const isRezoError = exports.isRezoError = RezoError.isRezoError;
 const Cancel = exports.Cancel = RezoError;

package/dist/index.d.ts

@@ -2628,8 +2628,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/browser.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/bun.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/deno.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/node.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/react-native.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/platform/worker.d.ts

@@ -2502,8 +2502,73 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
-	/** Whether to keep the connection alive for reuse */
+	/**
+	 * Whether to keep TCP connections alive for reuse across multiple requests.
+	 *
+	 * When enabled, the underlying TCP connection is kept open after a request completes,
+	 * allowing subsequent requests to the same host to reuse the connection. This reduces
+	 * latency by avoiding the overhead of establishing new connections (TCP handshake,
+	 * TLS negotiation for HTTPS).
+	 *
+	 * **Behavior:**
+	 * - `false` (default) - Connection closes after each request. Process exits immediately.
+	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 *
+	 * **When to use `keepAlive: true`:**
+	 * - Making multiple requests to the same host in sequence
+	 * - Long-running applications (servers, bots, scrapers)
+	 * - Performance-critical applications where connection overhead matters
+	 *
+	 * **When to use `keepAlive: false` (default):**
+	 * - Single requests or scripts that should exit immediately
+	 * - CLI tools that make one-off requests
+	 * - When you need predictable process termination
+	 *
+	 * @example
+	 * ```typescript
+	 * // Default: process exits immediately after request
+	 * const { data } = await rezo.get('https://api.example.com/data');
+	 *
+	 * // Keep connection alive for 1 minute (default) for subsequent requests
+	 * const client = new Rezo({ keepAlive: true });
+	 * await client.get('https://api.example.com/users');
+	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 *
+	 * // Custom keep-alive timeout (30 seconds)
+	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * ```
+	 *
+	 * @default false
+	 */
 	keepAlive?: boolean;
+	/**
+	 * How long to keep idle connections alive in milliseconds.
+	 *
+	 * Only applies when `keepAlive: true`. After this duration of inactivity,
+	 * the connection is closed automatically. This prevents resource leaks
+	 * from connections that are no longer needed.
+	 *
+	 * **Note:** Even with keep-alive enabled, the Node.js process can still exit
+	 * cleanly when there's no other work to do, thanks to socket unreferencing.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Keep connections alive for 30 seconds
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 30000
+	 * });
+	 *
+	 * // Keep connections alive for 2 minutes
+	 * const client = new Rezo({
+	 *   keepAlive: true,
+	 *   keepAliveMsecs: 120000
+	 * });
+	 * ```
+	 *
+	 * @default 60000 (1 minute)
+	 */
+	keepAliveMsecs?: number;
 	withoutBodyOnRedirect?: boolean;
 	autoSetReferer?: boolean;
 	autoSetOrigin?: boolean;

package/dist/plugin/index.cjs

@@ -1,36 +1,36 @@
-const _mod_rw5uzi = require('./crawler.cjs');
-exports.Crawler = _mod_rw5uzi.Crawler;;
-const _mod_uowipj = require('./crawler-options.cjs');
-exports.CrawlerOptions = _mod_uowipj.CrawlerOptions;;
-const _mod_o9zvdc = require('../cache/file-cacher.cjs');
-exports.FileCacher = _mod_o9zvdc.FileCacher;;
-const _mod_vh8a1z = require('../cache/url-store.cjs');
-exports.UrlStore = _mod_vh8a1z.UrlStore;;
-const _mod_7g0lot = require('./addon/oxylabs/index.cjs');
-exports.Oxylabs = _mod_7g0lot.Oxylabs;;
-const _mod_hjsucp = require('./addon/oxylabs/options.cjs');
-exports.OXYLABS_BROWSER_TYPES = _mod_hjsucp.OXYLABS_BROWSER_TYPES;
-exports.OXYLABS_COMMON_LOCALES = _mod_hjsucp.OXYLABS_COMMON_LOCALES;
-exports.OXYLABS_COMMON_GEO_LOCATIONS = _mod_hjsucp.OXYLABS_COMMON_GEO_LOCATIONS;
-exports.OXYLABS_US_STATES = _mod_hjsucp.OXYLABS_US_STATES;
-exports.OXYLABS_EUROPEAN_COUNTRIES = _mod_hjsucp.OXYLABS_EUROPEAN_COUNTRIES;
-exports.OXYLABS_ASIAN_COUNTRIES = _mod_hjsucp.OXYLABS_ASIAN_COUNTRIES;
-exports.getRandomOxylabsBrowserType = _mod_hjsucp.getRandomBrowserType;
-exports.getRandomOxylabsLocale = _mod_hjsucp.getRandomLocale;
-exports.getRandomOxylabsGeoLocation = _mod_hjsucp.getRandomGeoLocation;;
-const _mod_775tfq = require('./addon/decodo/index.cjs');
-exports.Decodo = _mod_775tfq.Decodo;;
-const _mod_hpojjz = require('./addon/decodo/options.cjs');
-exports.DECODO_DEVICE_TYPES = _mod_hpojjz.DECODO_DEVICE_TYPES;
-exports.DECODO_HEADLESS_MODES = _mod_hpojjz.DECODO_HEADLESS_MODES;
-exports.DECODO_COMMON_LOCALES = _mod_hpojjz.DECODO_COMMON_LOCALES;
-exports.DECODO_COMMON_COUNTRIES = _mod_hpojjz.DECODO_COMMON_COUNTRIES;
-exports.DECODO_EUROPEAN_COUNTRIES = _mod_hpojjz.DECODO_EUROPEAN_COUNTRIES;
-exports.DECODO_ASIAN_COUNTRIES = _mod_hpojjz.DECODO_ASIAN_COUNTRIES;
-exports.DECODO_US_STATES = _mod_hpojjz.DECODO_US_STATES;
-exports.DECODO_COMMON_CITIES = _mod_hpojjz.DECODO_COMMON_CITIES;
-exports.getRandomDecodoDeviceType = _mod_hpojjz.getRandomDeviceType;
-exports.getRandomDecodoLocale = _mod_hpojjz.getRandomLocale;
-exports.getRandomDecodoCountry = _mod_hpojjz.getRandomCountry;
-exports.getRandomDecodoCity = _mod_hpojjz.getRandomCity;
-exports.generateDecodoSessionId = _mod_hpojjz.generateSessionId;;
+const _mod_a9kn57 = require('./crawler.cjs');
+exports.Crawler = _mod_a9kn57.Crawler;;
+const _mod_6ccm6s = require('./crawler-options.cjs');
+exports.CrawlerOptions = _mod_6ccm6s.CrawlerOptions;;
+const _mod_7naagm = require('../cache/file-cacher.cjs');
+exports.FileCacher = _mod_7naagm.FileCacher;;
+const _mod_22i2ua = require('../cache/url-store.cjs');
+exports.UrlStore = _mod_22i2ua.UrlStore;;
+const _mod_37jf5t = require('./addon/oxylabs/index.cjs');
+exports.Oxylabs = _mod_37jf5t.Oxylabs;;
+const _mod_u1lbrx = require('./addon/oxylabs/options.cjs');
+exports.OXYLABS_BROWSER_TYPES = _mod_u1lbrx.OXYLABS_BROWSER_TYPES;
+exports.OXYLABS_COMMON_LOCALES = _mod_u1lbrx.OXYLABS_COMMON_LOCALES;
+exports.OXYLABS_COMMON_GEO_LOCATIONS = _mod_u1lbrx.OXYLABS_COMMON_GEO_LOCATIONS;
+exports.OXYLABS_US_STATES = _mod_u1lbrx.OXYLABS_US_STATES;
+exports.OXYLABS_EUROPEAN_COUNTRIES = _mod_u1lbrx.OXYLABS_EUROPEAN_COUNTRIES;
+exports.OXYLABS_ASIAN_COUNTRIES = _mod_u1lbrx.OXYLABS_ASIAN_COUNTRIES;
+exports.getRandomOxylabsBrowserType = _mod_u1lbrx.getRandomBrowserType;
+exports.getRandomOxylabsLocale = _mod_u1lbrx.getRandomLocale;
+exports.getRandomOxylabsGeoLocation = _mod_u1lbrx.getRandomGeoLocation;;
+const _mod_mozpwt = require('./addon/decodo/index.cjs');
+exports.Decodo = _mod_mozpwt.Decodo;;
+const _mod_g6f0a3 = require('./addon/decodo/options.cjs');
+exports.DECODO_DEVICE_TYPES = _mod_g6f0a3.DECODO_DEVICE_TYPES;
+exports.DECODO_HEADLESS_MODES = _mod_g6f0a3.DECODO_HEADLESS_MODES;
+exports.DECODO_COMMON_LOCALES = _mod_g6f0a3.DECODO_COMMON_LOCALES;
+exports.DECODO_COMMON_COUNTRIES = _mod_g6f0a3.DECODO_COMMON_COUNTRIES;
+exports.DECODO_EUROPEAN_COUNTRIES = _mod_g6f0a3.DECODO_EUROPEAN_COUNTRIES;
+exports.DECODO_ASIAN_COUNTRIES = _mod_g6f0a3.DECODO_ASIAN_COUNTRIES;
+exports.DECODO_US_STATES = _mod_g6f0a3.DECODO_US_STATES;
+exports.DECODO_COMMON_CITIES = _mod_g6f0a3.DECODO_COMMON_CITIES;
+exports.getRandomDecodoDeviceType = _mod_g6f0a3.getRandomDeviceType;
+exports.getRandomDecodoLocale = _mod_g6f0a3.getRandomLocale;
+exports.getRandomDecodoCountry = _mod_g6f0a3.getRandomCountry;
+exports.getRandomDecodoCity = _mod_g6f0a3.getRandomCity;
+exports.generateDecodoSessionId = _mod_g6f0a3.generateSessionId;;

package/dist/proxy/index.cjs

@@ -1,8 +1,8 @@
 const { SocksProxyAgent: RezoSocksProxy } = require("socks-proxy-agent");
 const { HttpsProxyAgent: RezoHttpsSocks } = require("https-proxy-agent");
 const { HttpProxyAgent: RezoHttpSocks } = require("http-proxy-agent");
-const _mod_6xqrgv = require('./manager.cjs');
-exports.ProxyManager = _mod_6xqrgv.ProxyManager;;
+const _mod_448ob0 = require('./manager.cjs');
+exports.ProxyManager = _mod_448ob0.ProxyManager;;
 function createOptions(uri, opts) {
   if (uri instanceof URL || typeof uri === "string") {
     return {