rezo 1.0.44 → 1.0.45

package/dist/adapters/entries/xhr.d.ts

@@ -1416,6 +1416,35 @@ export type OnTimeoutHook = (event: TimeoutEvent, config: RezoConfig) => void;
  * Use for cleanup, logging
  */
 export type OnAbortHook = (event: AbortEvent, config: RezoConfig) => void;
+/**
+ * Rate limit wait event data - fired when waiting due to rate limiting
+ */
+export interface RateLimitWaitEvent {
+	/** HTTP status code that triggered the wait (e.g., 429, 503) */
+	status: number;
+	/** Time to wait in milliseconds */
+	waitTime: number;
+	/** Current wait attempt number (1-indexed) */
+	attempt: number;
+	/** Maximum wait attempts configured */
+	maxAttempts: number;
+	/** Where the wait time was extracted from */
+	source: "header" | "body" | "function" | "default";
+	/** The header or body path used (if applicable) */
+	sourcePath?: string;
+	/** URL being requested */
+	url: string;
+	/** HTTP method of the request */
+	method: string;
+	/** Timestamp when the wait started */
+	timestamp: number;
+}
+/**
+ * Hook called when rate limit wait occurs
+ * Informational only - cannot abort the wait
+ * Use for logging, monitoring, alerting
+ */
+export type OnRateLimitWaitHook = (event: RateLimitWaitEvent, config: RezoConfig) => void | Promise<void>;
 /**
  * Hook called before a proxy is selected
  * Can return a specific proxy to override selection
@@ -1496,6 +1525,7 @@ export interface RezoHooks {
 	onTls: OnTlsHook[];
 	onTimeout: OnTimeoutHook[];
 	onAbort: OnAbortHook[];
+	onRateLimitWait: OnRateLimitWaitHook[];
 }
 /**
  * Create empty hooks object with all arrays initialized
@@ -2426,6 +2456,91 @@ export interface RezoRequestConfig<D = any> {
 		/** Weather to stop or continue retry when certain condition is met*/
 		condition?: (error: RezoError) => boolean | Promise<boolean>;
 	};
+	/**
+	 * Rate limit wait configuration - wait and retry when receiving rate limit responses.
+	 *
+	 * This feature runs BEFORE the retry system. When a rate-limiting status code is received,
+	 * the client will wait for the specified time and automatically retry the request.
+	 *
+	 * **Basic Usage:**
+	 * - `waitOnStatus: true` - Enable waiting on 429 status (default behavior)
+	 * - `waitOnStatus: [429, 503]` - Enable waiting on specific status codes
+	 *
+	 * **Wait Time Sources:**
+	 * - `'retry-after'` - Use standard Retry-After header (default)
+	 * - `{ header: 'X-RateLimit-Reset' }` - Use custom header
+	 * - `{ body: 'retry_after' }` - Extract from JSON response body
+	 * - Custom function for complex logic
+	 *
+	 * @example
+	 * ```typescript
+	 * // Wait on 429 using Retry-After header
+	 * await rezo.get(url, { waitOnStatus: true });
+	 *
+	 * // Wait on 429 using custom header
+	 * await rezo.get(url, {
+	 *   waitOnStatus: true,
+	 *   waitTimeSource: { header: 'X-RateLimit-Reset' }
+	 * });
+	 *
+	 * // Wait on 429 extracting time from JSON body
+	 * await rezo.get(url, {
+	 *   waitOnStatus: true,
+	 *   waitTimeSource: { body: 'data.retry_after' }
+	 * });
+	 *
+	 * // Custom function for complex APIs
+	 * await rezo.get(url, {
+	 *   waitOnStatus: [429, 503],
+	 *   waitTimeSource: (response) => {
+	 *     const reset = response.headers.get('x-ratelimit-reset');
+	 *     return reset ? parseInt(reset) - Math.floor(Date.now() / 1000) : null;
+	 *   }
+	 * });
+	 * ```
+	 */
+	waitOnStatus?: boolean | number[];
+	/**
+	 * Where to extract the wait time from when rate-limited.
+	 *
+	 * - `'retry-after'` - Standard Retry-After header (default)
+	 * - `{ header: string }` - Custom header name (e.g., 'X-RateLimit-Reset')
+	 * - `{ body: string }` - JSON path in response body (e.g., 'data.retry_after', 'wait_seconds')
+	 * - Function - Custom logic receiving the response, return seconds to wait or null
+	 *
+	 * @default 'retry-after'
+	 */
+	waitTimeSource?: "retry-after" | {
+		header: string;
+	} | {
+		body: string;
+	} | ((response: {
+		status: number;
+		headers: RezoHeaders;
+		data?: any;
+	}) => number | null);
+	/**
+	 * Maximum time to wait for rate limit in milliseconds.
+	 * If the extracted wait time exceeds this, the request will fail instead of waiting.
+	 * Set to 0 for unlimited wait time.
+	 *
+	 * @default 60000 (60 seconds)
+	 */
+	maxWaitTime?: number;
+	/**
+	 * Default wait time in milliseconds if the wait time source returns nothing.
+	 * Used as fallback when Retry-After header or body path is not present.
+	 *
+	 * @default 1000 (1 second)
+	 */
+	defaultWaitTime?: number;
+	/**
+	 * Maximum number of wait attempts before giving up.
+	 * After this many waits, the request will proceed to retry logic or fail.
+	 *
+	 * @default 3
+	 */
+	maxWaitAttempts?: number;
 	/** Whether to use a secure context for HTTPS requests */
 	useSecureContext?: boolean;
 	/** Custom secure context for TLS connections */

package/dist/adapters/fetch.cjs

@@ -10,6 +10,7 @@ const { DownloadResponse } = require('../responses/universal/download.cjs');
 const { UploadResponse } = require('../responses/universal/upload.cjs');
 const { isSameDomain, RezoPerformance } = require('../utils/tools.cjs');
 const { ResponseCache } = require('../cache/universal-response-cache.cjs');
+const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 const Environment = {
   isNode: typeof process !== "undefined" && process.versions?.node,
   isBrowser: typeof window !== "undefined" && typeof document !== "undefined",
@@ -555,6 +556,23 @@ async function executeFetchRequest(fetchOptions, config, options, perform, strea
         return response;
       }
       if (statusOnNext === "error") {
+        if (shouldWaitOnStatus(response.status, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+            url: fetchOptions.fullUrl || fetchOptions.url?.toString() || "",
+            method: fetchOptions.method || "GET",
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, fetchOptions);
         if (config.retry && statusCodes?.includes(response.status)) {
           if (maxRetries > retries) {

package/dist/adapters/fetch.js

@@ -10,6 +10,7 @@ import { DownloadResponse } from '../responses/universal/download.js';
 import { UploadResponse } from '../responses/universal/upload.js';
 import { isSameDomain, RezoPerformance } from '../utils/tools.js';
 import { ResponseCache } from '../cache/universal-response-cache.js';
+import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 const Environment = {
   isNode: typeof process !== "undefined" && process.versions?.node,
   isBrowser: typeof window !== "undefined" && typeof document !== "undefined",
@@ -555,6 +556,23 @@ async function executeFetchRequest(fetchOptions, config, options, perform, strea
         return response;
       }
       if (statusOnNext === "error") {
+        if (shouldWaitOnStatus(response.status, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+            url: fetchOptions.fullUrl || fetchOptions.url?.toString() || "",
+            method: fetchOptions.method || "GET",
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, fetchOptions);
         if (config.retry && statusCodes?.includes(response.status)) {
           if (maxRetries > retries) {

package/dist/adapters/http.cjs

@@ -21,6 +21,7 @@ const { getGlobalDNSCache } = require('../cache/dns-cache.cjs');
 const { ResponseCache } = require('../cache/response-cache.cjs');
 const { getGlobalAgentPool } = require('../utils/agent-pool.cjs');
 const { StagedTimeoutManager, parseStagedTimeouts } = require('../utils/staged-timeout.cjs');
+const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 const dns = require("node:dns");
 const debugLog = {
   requestStart: (config, url, method) => {
@@ -604,6 +605,23 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
         continue;
       }
       if (statusOnNext === "error") {
+        if (shouldWaitOnStatus(response.status, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+            url: fetchOptions.fullUrl || fetchOptions.url?.toString() || "",
+            method: fetchOptions.method || "GET",
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, fetchOptions);
         if (config.retry && statusCodes?.includes(response.status)) {
           if (maxRetries > retries) {

package/dist/adapters/http.js

@@ -21,6 +21,7 @@ import { getGlobalDNSCache } from '../cache/dns-cache.js';
 import { ResponseCache } from '../cache/response-cache.js';
 import { getGlobalAgentPool } from '../utils/agent-pool.js';
 import { StagedTimeoutManager, parseStagedTimeouts } from '../utils/staged-timeout.js';
+import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 import dns from "node:dns";
 const debugLog = {
   requestStart: (config, url, method) => {
@@ -604,6 +605,23 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
         continue;
       }
       if (statusOnNext === "error") {
+        if (shouldWaitOnStatus(response.status, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+            url: fetchOptions.fullUrl || fetchOptions.url?.toString() || "",
+            method: fetchOptions.method || "GET",
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, fetchOptions);
         if (config.retry && statusCodes?.includes(response.status)) {
           if (maxRetries > retries) {

package/dist/adapters/http2.cjs

@@ -18,6 +18,7 @@ const { isSameDomain, RezoPerformance } = require('../utils/tools.cjs');
 const { SocksClient } = require('../internal/agents/socks-client.cjs');
 const net = require("node:net");
 const { ResponseCache } = require('../cache/response-cache.cjs');
+const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 let zstdDecompressSync = null;
 let zstdChecked = false;
 const debugLog = {
@@ -960,6 +961,23 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         return response;
       }
       if (statusOnNext === "error") {
+        if (shouldWaitOnStatus(response.status, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+            url: fetchOptions.fullUrl || fetchOptions.url?.toString() || "",
+            method: fetchOptions.method || "GET",
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, fetchOptions);
         if (config.retry && statusCodes?.includes(response.status)) {
           if (maxRetries > retries) {

package/dist/adapters/http2.js

@@ -18,6 +18,7 @@ import { isSameDomain, RezoPerformance } from '../utils/tools.js';
 import { SocksClient } from '../internal/agents/socks-client.js';
 import * as net from "node:net";
 import { ResponseCache } from '../cache/response-cache.js';
+import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 let zstdDecompressSync = null;
 let zstdChecked = false;
 const debugLog = {
@@ -960,6 +961,23 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         return response;
       }
       if (statusOnNext === "error") {
+        if (shouldWaitOnStatus(response.status, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+            url: fetchOptions.fullUrl || fetchOptions.url?.toString() || "",
+            method: fetchOptions.method || "GET",
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, fetchOptions);
         if (config.retry && statusCodes?.includes(response.status)) {
           if (maxRetries > retries) {

package/dist/adapters/index.cjs

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

package/dist/adapters/xhr.cjs

@@ -10,6 +10,7 @@ const { DownloadResponse } = require('../responses/universal/download.cjs');
 const { UploadResponse } = require('../responses/universal/upload.cjs');
 const { RezoPerformance } = require('../utils/tools.cjs');
 const { ResponseCache } = require('../cache/universal-response-cache.cjs');
+const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 const Environment = {
   isBrowser: typeof window !== "undefined" && typeof document !== "undefined",
   hasXHR: typeof XMLHttpRequest !== "undefined",
@@ -390,6 +391,24 @@ async function executeXHRRequest(fetchOptions, config, options, perform, streamR
     try {
       const response = await executeSingleXHRRequest(config, fetchOptions, timing, streamResult, downloadResult, uploadResult);
       if (response instanceof RezoError) {
+        const errorStatus = response.status || 0;
+        if (shouldWaitOnStatus(errorStatus, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: errorStatus,
+            headers: response.response?.headers || new RezoHeaders,
+            data: response.response?.data,
+            url: fetchOptions.fullUrl || fetchOptions.url?.toString() || "",
+            method: fetchOptions.method || "GET",
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         config.errors.push({
           attempt: config.retryAttempts + 1,
           error: response,

package/dist/adapters/xhr.js

@@ -10,6 +10,7 @@ import { DownloadResponse } from '../responses/universal/download.js';
 import { UploadResponse } from '../responses/universal/upload.js';
 import { RezoPerformance } from '../utils/tools.js';
 import { ResponseCache } from '../cache/universal-response-cache.js';
+import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 const Environment = {
   isBrowser: typeof window !== "undefined" && typeof document !== "undefined",
   hasXHR: typeof XMLHttpRequest !== "undefined",
@@ -390,6 +391,24 @@ async function executeXHRRequest(fetchOptions, config, options, perform, streamR
     try {
       const response = await executeSingleXHRRequest(config, fetchOptions, timing, streamResult, downloadResult, uploadResult);
       if (response instanceof RezoError) {
+        const errorStatus = response.status || 0;
+        if (shouldWaitOnStatus(errorStatus, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: errorStatus,
+            headers: response.response?.headers || new RezoHeaders,
+            data: response.response?.data,
+            url: fetchOptions.fullUrl || fetchOptions.url?.toString() || "",
+            method: fetchOptions.method || "GET",
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         config.errors.push({
           attempt: config.retryAttempts + 1,
           error: response,

package/dist/cache/index.cjs

@@ -1,9 +1,9 @@
-const _mod_dh1qvy = require('./lru-cache.cjs');
-exports.LRUCache = _mod_dh1qvy.LRUCache;;
-const _mod_2s112k = require('./dns-cache.cjs');
-exports.DNSCache = _mod_2s112k.DNSCache;
-exports.getGlobalDNSCache = _mod_2s112k.getGlobalDNSCache;
-exports.resetGlobalDNSCache = _mod_2s112k.resetGlobalDNSCache;;
-const _mod_xow5u3 = require('./response-cache.cjs');
-exports.ResponseCache = _mod_xow5u3.ResponseCache;
-exports.normalizeResponseCacheConfig = _mod_xow5u3.normalizeResponseCacheConfig;;
+const _mod_0ku4z2 = require('./lru-cache.cjs');
+exports.LRUCache = _mod_0ku4z2.LRUCache;;
+const _mod_odvwch = require('./dns-cache.cjs');
+exports.DNSCache = _mod_odvwch.DNSCache;
+exports.getGlobalDNSCache = _mod_odvwch.getGlobalDNSCache;
+exports.resetGlobalDNSCache = _mod_odvwch.resetGlobalDNSCache;;
+const _mod_b9x6qw = require('./response-cache.cjs');
+exports.ResponseCache = _mod_b9x6qw.ResponseCache;
+exports.normalizeResponseCacheConfig = _mod_b9x6qw.normalizeResponseCacheConfig;;

package/dist/core/hooks.cjs

@@ -24,7 +24,8 @@ function createDefaultHooks() {
     onDns: [],
     onTls: [],
     onTimeout: [],
-    onAbort: []
+    onAbort: [],
+    onRateLimitWait: []
   };
 }
 function mergeHooks(base, overrides) {
@@ -55,7 +56,8 @@ function mergeHooks(base, overrides) {
     onDns: [...base.onDns, ...overrides.onDns || []],
     onTls: [...base.onTls, ...overrides.onTls || []],
     onTimeout: [...base.onTimeout, ...overrides.onTimeout || []],
-    onAbort: [...base.onAbort, ...overrides.onAbort || []]
+    onAbort: [...base.onAbort, ...overrides.onAbort || []],
+    onRateLimitWait: [...base.onRateLimitWait, ...overrides.onRateLimitWait || []]
   };
 }
 function serializeHooks(hooks) {

package/dist/core/hooks.js

@@ -24,7 +24,8 @@ export function createDefaultHooks() {
     onDns: [],
     onTls: [],
     onTimeout: [],
-    onAbort: []
+    onAbort: [],
+    onRateLimitWait: []
   };
 }
 export function mergeHooks(base, overrides) {
@@ -55,7 +56,8 @@ export function mergeHooks(base, overrides) {
     onDns: [...base.onDns, ...overrides.onDns || []],
     onTls: [...base.onTls, ...overrides.onTls || []],
     onTimeout: [...base.onTimeout, ...overrides.onTimeout || []],
-    onAbort: [...base.onAbort, ...overrides.onAbort || []]
+    onAbort: [...base.onAbort, ...overrides.onAbort || []],
+    onRateLimitWait: [...base.onRateLimitWait, ...overrides.onRateLimitWait || []]
   };
 }
 export function serializeHooks(hooks) {

package/dist/crawler/index.cjs

@@ -1,40 +1,40 @@
-const _mod_uzdw07 = require('./crawler.cjs');
-exports.Crawler = _mod_uzdw07.Crawler;;
-const _mod_fk2i9s = require('./crawler-options.cjs');
-exports.CrawlerOptions = _mod_fk2i9s.CrawlerOptions;;
-const _mod_y9972f = require('./plugin/robots-txt.cjs');
-exports.RobotsTxt = _mod_y9972f.RobotsTxt;;
-const _mod_y7t1zo = require('./plugin/file-cacher.cjs');
-exports.FileCacher = _mod_y7t1zo.FileCacher;;
-const _mod_ecu03i = require('./plugin/url-store.cjs');
-exports.UrlStore = _mod_ecu03i.UrlStore;;
-const _mod_kxfnq7 = require('./plugin/navigation-history.cjs');
-exports.NavigationHistory = _mod_kxfnq7.NavigationHistory;;
-const _mod_bg9vts = require('./addon/oxylabs/index.cjs');
-exports.Oxylabs = _mod_bg9vts.Oxylabs;;
-const _mod_zd2i1t = require('./addon/oxylabs/options.cjs');
-exports.OXYLABS_BROWSER_TYPES = _mod_zd2i1t.OXYLABS_BROWSER_TYPES;
-exports.OXYLABS_COMMON_LOCALES = _mod_zd2i1t.OXYLABS_COMMON_LOCALES;
-exports.OXYLABS_COMMON_GEO_LOCATIONS = _mod_zd2i1t.OXYLABS_COMMON_GEO_LOCATIONS;
-exports.OXYLABS_US_STATES = _mod_zd2i1t.OXYLABS_US_STATES;
-exports.OXYLABS_EUROPEAN_COUNTRIES = _mod_zd2i1t.OXYLABS_EUROPEAN_COUNTRIES;
-exports.OXYLABS_ASIAN_COUNTRIES = _mod_zd2i1t.OXYLABS_ASIAN_COUNTRIES;
-exports.getRandomOxylabsBrowserType = _mod_zd2i1t.getRandomBrowserType;
-exports.getRandomOxylabsLocale = _mod_zd2i1t.getRandomLocale;
-exports.getRandomOxylabsGeoLocation = _mod_zd2i1t.getRandomGeoLocation;;
-const _mod_gr8483 = require('./addon/decodo/index.cjs');
-exports.Decodo = _mod_gr8483.Decodo;;
-const _mod_km63k6 = require('./addon/decodo/options.cjs');
-exports.DECODO_DEVICE_TYPES = _mod_km63k6.DECODO_DEVICE_TYPES;
-exports.DECODO_HEADLESS_MODES = _mod_km63k6.DECODO_HEADLESS_MODES;
-exports.DECODO_COMMON_LOCALES = _mod_km63k6.DECODO_COMMON_LOCALES;
-exports.DECODO_COMMON_COUNTRIES = _mod_km63k6.DECODO_COMMON_COUNTRIES;
-exports.DECODO_EUROPEAN_COUNTRIES = _mod_km63k6.DECODO_EUROPEAN_COUNTRIES;
-exports.DECODO_ASIAN_COUNTRIES = _mod_km63k6.DECODO_ASIAN_COUNTRIES;
-exports.DECODO_US_STATES = _mod_km63k6.DECODO_US_STATES;
-exports.DECODO_COMMON_CITIES = _mod_km63k6.DECODO_COMMON_CITIES;
-exports.getRandomDecodoDeviceType = _mod_km63k6.getRandomDeviceType;
-exports.getRandomDecodoLocale = _mod_km63k6.getRandomLocale;
-exports.getRandomDecodoCountry = _mod_km63k6.getRandomCountry;
-exports.getRandomDecodoCity = _mod_km63k6.getRandomCity;
-exports.generateDecodoSessionId = _mod_km63k6.generateSessionId;;
+const _mod_ohy0ht = require('./crawler.cjs');
+exports.Crawler = _mod_ohy0ht.Crawler;;
+const _mod_lcpyaf = require('./crawler-options.cjs');
+exports.CrawlerOptions = _mod_lcpyaf.CrawlerOptions;;
+const _mod_i89xd7 = require('./plugin/robots-txt.cjs');
+exports.RobotsTxt = _mod_i89xd7.RobotsTxt;;
+const _mod_5bw1j8 = require('./plugin/file-cacher.cjs');
+exports.FileCacher = _mod_5bw1j8.FileCacher;;
+const _mod_fhan3k = require('./plugin/url-store.cjs');
+exports.UrlStore = _mod_fhan3k.UrlStore;;
+const _mod_23xqla = require('./plugin/navigation-history.cjs');
+exports.NavigationHistory = _mod_23xqla.NavigationHistory;;
+const _mod_bugokk = require('./addon/oxylabs/index.cjs');
+exports.Oxylabs = _mod_bugokk.Oxylabs;;
+const _mod_rqu5cf = require('./addon/oxylabs/options.cjs');
+exports.OXYLABS_BROWSER_TYPES = _mod_rqu5cf.OXYLABS_BROWSER_TYPES;
+exports.OXYLABS_COMMON_LOCALES = _mod_rqu5cf.OXYLABS_COMMON_LOCALES;
+exports.OXYLABS_COMMON_GEO_LOCATIONS = _mod_rqu5cf.OXYLABS_COMMON_GEO_LOCATIONS;
+exports.OXYLABS_US_STATES = _mod_rqu5cf.OXYLABS_US_STATES;
+exports.OXYLABS_EUROPEAN_COUNTRIES = _mod_rqu5cf.OXYLABS_EUROPEAN_COUNTRIES;
+exports.OXYLABS_ASIAN_COUNTRIES = _mod_rqu5cf.OXYLABS_ASIAN_COUNTRIES;
+exports.getRandomOxylabsBrowserType = _mod_rqu5cf.getRandomBrowserType;
+exports.getRandomOxylabsLocale = _mod_rqu5cf.getRandomLocale;
+exports.getRandomOxylabsGeoLocation = _mod_rqu5cf.getRandomGeoLocation;;
+const _mod_eh5umb = require('./addon/decodo/index.cjs');
+exports.Decodo = _mod_eh5umb.Decodo;;
+const _mod_pa9reb = require('./addon/decodo/options.cjs');
+exports.DECODO_DEVICE_TYPES = _mod_pa9reb.DECODO_DEVICE_TYPES;
+exports.DECODO_HEADLESS_MODES = _mod_pa9reb.DECODO_HEADLESS_MODES;
+exports.DECODO_COMMON_LOCALES = _mod_pa9reb.DECODO_COMMON_LOCALES;
+exports.DECODO_COMMON_COUNTRIES = _mod_pa9reb.DECODO_COMMON_COUNTRIES;
+exports.DECODO_EUROPEAN_COUNTRIES = _mod_pa9reb.DECODO_EUROPEAN_COUNTRIES;
+exports.DECODO_ASIAN_COUNTRIES = _mod_pa9reb.DECODO_ASIAN_COUNTRIES;
+exports.DECODO_US_STATES = _mod_pa9reb.DECODO_US_STATES;
+exports.DECODO_COMMON_CITIES = _mod_pa9reb.DECODO_COMMON_CITIES;
+exports.getRandomDecodoDeviceType = _mod_pa9reb.getRandomDeviceType;
+exports.getRandomDecodoLocale = _mod_pa9reb.getRandomLocale;
+exports.getRandomDecodoCountry = _mod_pa9reb.getRandomCountry;
+exports.getRandomDecodoCity = _mod_pa9reb.getRandomCity;
+exports.generateDecodoSessionId = _mod_pa9reb.generateSessionId;;