rezo 1.0.10 → 1.0.12

package/dist/adapters/entries/curl.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;
@@ -4104,6 +4169,7 @@ export declare class Rezo {
 	private __create;
 	/** Get the cookie jar for this instance */
 	get cookieJar(): RezoCookieJar;
+	set cookieJar(jar: RezoCookieJar);
 	/**
 	 * Save cookies to file (if cookieFile is configured).
 	 * Can also specify a different path to save to.

package/dist/adapters/entries/fetch.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;
@@ -4104,6 +4169,7 @@ export declare class Rezo {
 	private __create;
 	/** Get the cookie jar for this instance */
 	get cookieJar(): RezoCookieJar;
+	set cookieJar(jar: RezoCookieJar);
 	/**
 	 * Save cookies to file (if cookieFile is configured).
 	 * Can also specify a different path to save to.

package/dist/adapters/entries/http.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;
@@ -4104,6 +4169,7 @@ export declare class Rezo {
 	private __create;
 	/** Get the cookie jar for this instance */
 	get cookieJar(): RezoCookieJar;
+	set cookieJar(jar: RezoCookieJar);
 	/**
 	 * Save cookies to file (if cookieFile is configured).
 	 * Can also specify a different path to save to.

package/dist/adapters/entries/http2.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;
@@ -4104,6 +4169,7 @@ export declare class Rezo {
 	private __create;
 	/** Get the cookie jar for this instance */
 	get cookieJar(): RezoCookieJar;
+	set cookieJar(jar: RezoCookieJar);
 	/**
 	 * Save cookies to file (if cookieFile is configured).
 	 * Can also specify a different path to save to.

package/dist/adapters/entries/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;
@@ -4104,6 +4169,7 @@ export declare class Rezo {
 	private __create;
 	/** Get the cookie jar for this instance */
 	get cookieJar(): RezoCookieJar;
+	set cookieJar(jar: RezoCookieJar);
 	/**
 	 * Save cookies to file (if cookieFile is configured).
 	 * Can also specify a different path to save to.

package/dist/adapters/entries/xhr.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;
@@ -4104,6 +4169,7 @@ export declare class Rezo {
 	private __create;
 	/** Get the cookie jar for this instance */
 	get cookieJar(): RezoCookieJar;
+	set cookieJar(jar: RezoCookieJar);
 	/**
 	 * Save cookies to file (if cookieFile is configured).
 	 * Can also specify a different path to save to.

package/dist/adapters/http.cjs

@@ -767,6 +767,9 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
           }
         });
         req.on("socket", (socket) => {
+          if (socket && typeof socket.unref === "function") {
+            socket.unref();
+          }
           timing.dnsStart = performance.now();
           socket.on("lookup", () => {
             if (!config.timing.dnsMs) {
@@ -944,13 +947,16 @@ function buildHTTPOptions(fetchOptions, isSecure, url) {
     rejectUnauthorized,
     useSecureContext = true,
     auth,
-    dnsCache: dnsCacheOption
+    dnsCache: dnsCacheOption,
+    keepAlive = false,
+    keepAliveMsecs = 60000
   } = fetchOptions;
   const secureContext = isSecure && useSecureContext ? new https.Agent({
     secureContext: createSecureContext(),
     servername: url.host,
     rejectUnauthorized,
-    keepAlive: true
+    keepAlive,
+    keepAliveMsecs: keepAlive ? keepAliveMsecs : undefined
   }) : undefined;
   const customAgent = url.protocol === "https:" && httpsAgent ? httpsAgent : httpAgent ? httpAgent : undefined;
   const agent = parseProxy(proxy) || customAgent || secureContext;

package/dist/adapters/http.js

@@ -767,6 +767,9 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
           }
         });
         req.on("socket", (socket) => {
+          if (socket && typeof socket.unref === "function") {
+            socket.unref();
+          }
           timing.dnsStart = performance.now();
           socket.on("lookup", () => {
             if (!config.timing.dnsMs) {
@@ -944,13 +947,16 @@ function buildHTTPOptions(fetchOptions, isSecure, url) {
     rejectUnauthorized,
     useSecureContext = true,
     auth,
-    dnsCache: dnsCacheOption
+    dnsCache: dnsCacheOption,
+    keepAlive = false,
+    keepAliveMsecs = 60000
   } = fetchOptions;
   const secureContext = isSecure && useSecureContext ? new https.Agent({
     secureContext: createSecureContext(),
     servername: url.host,
     rejectUnauthorized,
-    keepAlive: true
+    keepAlive,
+    keepAliveMsecs: keepAlive ? keepAliveMsecs : undefined
   }) : undefined;
   const customAgent = url.protocol === "https:" && httpsAgent ? httpsAgent : httpAgent ? httpAgent : undefined;
   const agent = parseProxy(proxy) || customAgent || secureContext;

package/dist/adapters/http2.cjs

@@ -147,6 +147,10 @@ class Http2SessionPool {
           settled = true;
           if (timeoutId)
             clearTimeout(timeoutId);
+          const socket = session.socket;
+          if (socket && typeof socket.unref === "function") {
+            socket.unref();
+          }
           resolve(session);
         }
       });

package/dist/adapters/http2.js

@@ -147,6 +147,10 @@ class Http2SessionPool {
           settled = true;
           if (timeoutId)
             clearTimeout(timeoutId);
+          const socket = session.socket;
+          if (socket && typeof socket.unref === "function") {
+            socket.unref();
+          }
           resolve(session);
         }
       });

package/dist/adapters/index.cjs

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

package/dist/cache/index.cjs

@@ -1,13 +1,13 @@
-const _mod_vpvlaj = require('./lru-cache.cjs');
-exports.LRUCache = _mod_vpvlaj.LRUCache;;
-const _mod_37phlu = require('./dns-cache.cjs');
-exports.DNSCache = _mod_37phlu.DNSCache;
-exports.getGlobalDNSCache = _mod_37phlu.getGlobalDNSCache;
-exports.resetGlobalDNSCache = _mod_37phlu.resetGlobalDNSCache;;
-const _mod_23ag1b = require('./response-cache.cjs');
-exports.ResponseCache = _mod_23ag1b.ResponseCache;
-exports.normalizeResponseCacheConfig = _mod_23ag1b.normalizeResponseCacheConfig;;
-const _mod_ni47l3 = require('./file-cacher.cjs');
-exports.FileCacher = _mod_ni47l3.FileCacher;;
-const _mod_pgav4z = require('./url-store.cjs');
-exports.UrlStore = _mod_pgav4z.UrlStore;;
+const _mod_2rlcbw = require('./lru-cache.cjs');
+exports.LRUCache = _mod_2rlcbw.LRUCache;;
+const _mod_faep7r = require('./dns-cache.cjs');
+exports.DNSCache = _mod_faep7r.DNSCache;
+exports.getGlobalDNSCache = _mod_faep7r.getGlobalDNSCache;
+exports.resetGlobalDNSCache = _mod_faep7r.resetGlobalDNSCache;;
+const _mod_kp3skc = require('./response-cache.cjs');
+exports.ResponseCache = _mod_kp3skc.ResponseCache;
+exports.normalizeResponseCacheConfig = _mod_kp3skc.normalizeResponseCacheConfig;;
+const _mod_dok148 = require('./file-cacher.cjs');
+exports.FileCacher = _mod_dok148.FileCacher;;
+const _mod_wzzzfr = require('./url-store.cjs');
+exports.UrlStore = _mod_wzzzfr.UrlStore;;

package/dist/core/rezo.cjs

@@ -361,6 +361,9 @@ class Rezo {
   get cookieJar() {
     return this.jar;
   }
+  set cookieJar(jar) {
+    this.jar = jar;
+  }
   saveCookies(filePath) {
     if (filePath) {
       this.jar.saveToFile(filePath);
@@ -397,6 +400,8 @@ class Rezo {
     }, this.defaults, this.jar);
   }
   setCookies(cookies, url, startNew) {
+    if (!this.jar)
+      this.jar = new RezoCookieJar;
     if (startNew)
       this.jar.removeAllCookiesSync();
     this.jar.setCookiesSync(cookies, url);

package/dist/core/rezo.js

@@ -361,6 +361,9 @@ export class Rezo {
   get cookieJar() {
     return this.jar;
   }
+  set cookieJar(jar) {
+    this.jar = jar;
+  }
   saveCookies(filePath) {
     if (filePath) {
       this.jar.saveToFile(filePath);
@@ -397,6 +400,8 @@ export class Rezo {
     }, this.defaults, this.jar);
   }
   setCookies(cookies, url, startNew) {
+    if (!this.jar)
+      this.jar = new RezoCookieJar;
     if (startNew)
       this.jar.removeAllCookiesSync();
     this.jar.setCookiesSync(cookies, url);