rezo 1.0.2 → 1.0.4

package/dist/crawler.d.ts

@@ -1122,6 +1122,292 @@ export interface RezoDownloadResponse extends DownloadResponse {
  */
 export interface RezoUploadResponse extends UploadResponse {
 }
+/**
+ * Rezo ProxyManager Types
+ * Type definitions for advanced proxy rotation and management
+ *
+ * @module proxy/types
+ * @author Yuniq Solutions Team
+ * @version 1.0.0
+ */
+/** Supported proxy protocols */
+export type ProxyProtocol = "socks4" | "socks5" | "http" | "https";
+/**
+ * Proxy information structure
+ * Represents a single proxy server with its connection details
+ */
+export interface ProxyInfo {
+	/** Unique identifier for the proxy (auto-generated if not provided) */
+	id?: string;
+	/** The proxy protocol to use */
+	protocol: ProxyProtocol;
+	/** Proxy server hostname or IP address */
+	host: string;
+	/** Proxy server port number */
+	port: number;
+	/** Optional authentication credentials for the proxy */
+	auth?: {
+		/** Username for proxy authentication */
+		username: string;
+		/** Password for proxy authentication */
+		password: string;
+	};
+	/** Optional label for identification/logging */
+	label?: string;
+	/** Optional metadata for custom tracking */
+	metadata?: Record<string, unknown>;
+}
+/**
+ * Proxy rotation strategies
+ * - `random`: Select a random proxy from the pool for each request
+ * - `sequential`: Use proxies in order, optionally rotating after N requests
+ * - `per-proxy-limit`: Use each proxy for a maximum number of requests, then permanently remove
+ */
+export type RotationStrategy = "random" | "sequential" | "per-proxy-limit";
+/**
+ * Rotation configuration for different strategies
+ */
+export type RotationConfig = {
+	/** Random selection from available proxies */
+	rotation: "random";
+} | {
+	/** Sequential rotation through proxy list */
+	rotation: "sequential";
+	/** Number of requests before rotating to next proxy (default: 1) */
+	requestsPerProxy?: number;
+} | {
+	/** Use each proxy for a limited number of total requests, then remove */
+	rotation: "per-proxy-limit";
+	/** Maximum requests per proxy before permanent removal */
+	limit: number;
+};
+/**
+ * Cooldown configuration for disabled proxies
+ */
+export interface ProxyCooldownConfig {
+	/** Whether to enable automatic re-enabling after cooldown */
+	enabled: boolean;
+	/** Duration in milliseconds before re-enabling a disabled proxy */
+	durationMs: number;
+}
+/**
+ * Base proxy manager configuration (without rotation)
+ * Complete configuration for proxy rotation, filtering, and failure handling
+ */
+export interface ProxyManagerBaseConfig {
+	/** Array of proxies to manage */
+	proxies: ProxyInfo[];
+	/**
+	 * Whitelist patterns for URLs that should use proxy
+	 * - String: exact domain match (e.g., 'api.example.com') or subdomain match (e.g., 'example.com' matches '*.example.com')
+	 * - RegExp: regex pattern to test against full URL
+	 * If not set, all URLs use proxy
+	 */
+	whitelist?: (string | RegExp)[];
+	/**
+	 * Blacklist patterns for URLs that should NOT use proxy (go direct)
+	 * - String: exact domain match or subdomain match
+	 * - RegExp: regex pattern to test against full URL
+	 * Blacklist is checked after whitelist
+	 */
+	blacklist?: (string | RegExp)[];
+	/**
+	 * Automatically disable proxies after consecutive failures
+	 * @default false
+	 */
+	autoDisableDeadProxies?: boolean;
+	/**
+	 * Number of consecutive failures before disabling a proxy
+	 * Only applies when autoDisableDeadProxies is true
+	 * @default 3
+	 */
+	maxFailures?: number;
+	/**
+	 * Cooldown configuration for disabled proxies
+	 * If not set or enabled: false, proxies are permanently removed when disabled
+	 */
+	cooldown?: ProxyCooldownConfig;
+	/**
+	 * Whether to throw error when no proxy is available
+	 * - true (default): Throw RezoError when no proxies available
+	 * - false: Proceed with direct connection (no proxy)
+	 * @default true
+	 */
+	failWithoutProxy?: boolean;
+	/**
+	 * Whether to retry the request with next proxy on failure
+	 * @default false
+	 */
+	retryWithNextProxy?: boolean;
+	/**
+	 * Maximum retry attempts when retryWithNextProxy is enabled
+	 * @default 3
+	 */
+	maxProxyRetries?: number;
+}
+/**
+ * Full proxy manager configuration
+ * Combines base config with rotation strategy
+ */
+export type ProxyManagerConfig = ProxyManagerBaseConfig & RotationConfig;
+/**
+ * Internal proxy state tracking
+ * Used internally by ProxyManager to track usage and failures
+ */
+export interface ProxyState {
+	/** The proxy info */
+	proxy: ProxyInfo;
+	/** Number of requests made through this proxy */
+	requestCount: number;
+	/** Number of consecutive failures */
+	failureCount: number;
+	/** Total number of successful requests */
+	successCount: number;
+	/** Total number of failed requests */
+	totalFailures: number;
+	/** Whether the proxy is currently active */
+	isActive: boolean;
+	/** Reason for being disabled (if applicable) */
+	disabledReason?: "dead" | "limit-reached" | "manual";
+	/** Timestamp when proxy was disabled */
+	disabledAt?: number;
+	/** Timestamp when proxy will be re-enabled (if cooldown enabled) */
+	reenableAt?: number;
+	/** Last successful request timestamp */
+	lastSuccessAt?: number;
+	/** Last failure timestamp */
+	lastFailureAt?: number;
+	/** Last error message */
+	lastError?: string;
+}
+/**
+ * Proxy manager status snapshot
+ * Provides overview of all proxies in the manager
+ */
+export interface ProxyManagerStatus {
+	/** Active proxies available for use */
+	active: ProxyInfo[];
+	/** Disabled proxies (dead or limit reached) */
+	disabled: ProxyInfo[];
+	/** Proxies in cooldown waiting to be re-enabled */
+	cooldown: ProxyInfo[];
+	/** Total number of proxies */
+	total: number;
+	/** Current rotation strategy */
+	rotation: RotationStrategy;
+	/** Total requests made through the manager */
+	totalRequests: number;
+	/** Total successful requests */
+	totalSuccesses: number;
+	/** Total failed requests */
+	totalFailures: number;
+}
+/**
+ * Result from proxy selection
+ */
+export interface ProxySelectionResult {
+	/** Selected proxy (null if should go direct) */
+	proxy: ProxyInfo | null;
+	/** Reason for selection result */
+	reason: "selected" | "whitelist-no-match" | "blacklist-match" | "no-proxies-available" | "disabled";
+}
+/**
+ * Context for beforeProxySelect hook
+ */
+export interface BeforeProxySelectContext {
+	/** Request URL */
+	url: string;
+	/** Available active proxies */
+	proxies: ProxyInfo[];
+	/** Whether this is a retry attempt */
+	isRetry: boolean;
+	/** Retry count (0 for initial request) */
+	retryCount: number;
+}
+/**
+ * Context for afterProxySelect hook
+ */
+export interface AfterProxySelectContext {
+	/** Request URL */
+	url: string;
+	/** Selected proxy (null if going direct) */
+	proxy: ProxyInfo | null;
+	/** Selection reason */
+	reason: ProxySelectionResult["reason"];
+}
+/**
+ * Context for beforeProxyError hook
+ */
+export interface BeforeProxyErrorContext {
+	/** The proxy that failed */
+	proxy: ProxyInfo;
+	/** The error that occurred */
+	error: Error;
+	/** Request URL */
+	url: string;
+	/** Current failure count for this proxy */
+	failureCount: number;
+	/** Whether proxy will be disabled after this error */
+	willBeDisabled: boolean;
+}
+/**
+ * Context for afterProxyError hook
+ */
+export interface AfterProxyErrorContext {
+	/** The proxy that failed */
+	proxy: ProxyInfo;
+	/** The error that occurred */
+	error: Error;
+	/** Action taken after error */
+	action: "retry-next-proxy" | "disabled" | "continue";
+	/** Next proxy for retry (if action is 'retry-next-proxy') */
+	nextProxy?: ProxyInfo;
+}
+/**
+ * Context for beforeProxyDisable hook
+ * Return false to prevent disabling
+ */
+export interface BeforeProxyDisableContext {
+	/** The proxy about to be disabled */
+	proxy: ProxyInfo;
+	/** Reason for disabling */
+	reason: "dead" | "limit-reached" | "manual";
+	/** Current proxy state */
+	state: ProxyState;
+}
+/**
+ * Context for afterProxyDisable hook
+ */
+export interface AfterProxyDisableContext {
+	/** The proxy that was disabled */
+	proxy: ProxyInfo;
+	/** Reason for disabling */
+	reason: "dead" | "limit-reached" | "manual";
+	/** Whether cooldown is enabled for re-enabling */
+	hasCooldown: boolean;
+	/** Timestamp when proxy will be re-enabled (if cooldown enabled) */
+	reenableAt?: number;
+}
+/**
+ * Context for afterProxyRotate hook
+ */
+export interface AfterProxyRotateContext {
+	/** Previous proxy (null if first selection) */
+	from: ProxyInfo | null;
+	/** New proxy */
+	to: ProxyInfo;
+	/** Reason for rotation */
+	reason: "scheduled" | "failure" | "limit-reached";
+}
+/**
+ * Context for afterProxyEnable hook
+ */
+export interface AfterProxyEnableContext {
+	/** The proxy that was enabled */
+	proxy: ProxyInfo;
+	/** Reason for enabling */
+	reason: "cooldown-expired" | "manual";
+}
 /**
  * Context provided to beforeRequest hook
  * Contains metadata about the current request state
@@ -1400,6 +1686,46 @@ export type OnTimeoutHook = (event: TimeoutEvent, config: RezoConfig) => void;
  * Use for cleanup, logging
  */
 export type OnAbortHook = (event: AbortEvent, config: RezoConfig) => void;
+/**
+ * Hook called before a proxy is selected
+ * Can return a specific proxy to override selection
+ */
+export type BeforeProxySelectHook = (context: BeforeProxySelectContext) => ProxyInfo | void | Promise<ProxyInfo | void>;
+/**
+ * Hook called after a proxy is selected
+ * Use for logging, analytics
+ */
+export type AfterProxySelectHook = (context: AfterProxySelectContext) => void | Promise<void>;
+/**
+ * Hook called before a proxy error is processed
+ * Use for error inspection, custom handling
+ */
+export type BeforeProxyErrorHook = (context: BeforeProxyErrorContext) => void | Promise<void>;
+/**
+ * Hook called after a proxy error is processed
+ * Use for error logging, fallback logic
+ */
+export type AfterProxyErrorHook = (context: AfterProxyErrorContext) => void | Promise<void>;
+/**
+ * Hook called before a proxy is disabled
+ * Return false to prevent disabling
+ */
+export type BeforeProxyDisableHook = (context: BeforeProxyDisableContext) => boolean | void | Promise<boolean | void>;
+/**
+ * Hook called after a proxy is disabled
+ * Use for notifications, logging
+ */
+export type AfterProxyDisableHook = (context: AfterProxyDisableContext) => void | Promise<void>;
+/**
+ * Hook called when proxy rotation occurs
+ * Use for monitoring rotation patterns
+ */
+export type AfterProxyRotateHook = (context: AfterProxyRotateContext) => void | Promise<void>;
+/**
+ * Hook called when a proxy is re-enabled
+ * Use for notifications, logging
+ */
+export type AfterProxyEnableHook = (context: AfterProxyEnableContext) => void | Promise<void>;
 /**
  * Collection of all hook types
  * All hooks are arrays to allow multiple handlers
@@ -1416,6 +1742,14 @@ export interface RezoHooks {
 	afterParse: AfterParseHook[];
 	beforeCookie: BeforeCookieHook[];
 	afterCookie: AfterCookieHook[];
+	beforeProxySelect: BeforeProxySelectHook[];
+	afterProxySelect: AfterProxySelectHook[];
+	beforeProxyError: BeforeProxyErrorHook[];
+	afterProxyError: AfterProxyErrorHook[];
+	beforeProxyDisable: BeforeProxyDisableHook[];
+	afterProxyDisable: AfterProxyDisableHook[];
+	afterProxyRotate: AfterProxyRotateHook[];
+	afterProxyEnable: AfterProxyEnableHook[];
 	onSocket: OnSocketHook[];
 	onDns: OnDnsHook[];
 	onTls: OnTlsHook[];
@@ -1812,16 +2146,13 @@ declare class RezoError<T = any> extends Error {
 	toString(): string;
 	getFullDetails(): string;
 }
-/**
- * Supported proxy protocols for network requests
- */
-export type ProxyProtocol = "http" | "https" | "socks4" | "socks5";
+type ProxyProtocol$1 = "http" | "https" | "socks4" | "socks5";
 /**
  * Configuration options for proxy connections
  */
 export type ProxyOptions = {
 	/** The proxy protocol to use */
-	protocol: ProxyProtocol;
+	protocol: ProxyProtocol$1;
 	/** Proxy server hostname or IP address */
 	host: string;
 	/** Proxy server port number */
@@ -2319,6 +2650,162 @@ declare class ResponseCache {
 	get isPersistent(): boolean;
 	getConfig(): ResponseCacheConfig;
 }
+type BeforeProxySelectHook$1 = (context: BeforeProxySelectContext) => ProxyInfo | void | Promise<ProxyInfo | void>;
+type AfterProxySelectHook$1 = (context: AfterProxySelectContext) => void | Promise<void>;
+type BeforeProxyErrorHook$1 = (context: BeforeProxyErrorContext) => void | Promise<void>;
+type AfterProxyErrorHook$1 = (context: AfterProxyErrorContext) => void | Promise<void>;
+type BeforeProxyDisableHook$1 = (context: BeforeProxyDisableContext) => boolean | void | Promise<boolean | void>;
+type AfterProxyDisableHook$1 = (context: AfterProxyDisableContext) => void | Promise<void>;
+type AfterProxyRotateHook$1 = (context: AfterProxyRotateContext) => void | Promise<void>;
+type AfterProxyEnableHook$1 = (context: AfterProxyEnableContext) => void | Promise<void>;
+/**
+ * Proxy hooks collection for ProxyManager events
+ */
+export interface ProxyHooks {
+	beforeProxySelect: BeforeProxySelectHook$1[];
+	afterProxySelect: AfterProxySelectHook$1[];
+	beforeProxyError: BeforeProxyErrorHook$1[];
+	afterProxyError: AfterProxyErrorHook$1[];
+	beforeProxyDisable: BeforeProxyDisableHook$1[];
+	afterProxyDisable: AfterProxyDisableHook$1[];
+	afterProxyRotate: AfterProxyRotateHook$1[];
+	afterProxyEnable: AfterProxyEnableHook$1[];
+}
+declare class ProxyManager {
+	/** Configuration for the proxy manager */
+	readonly config: ProxyManagerConfig;
+	/** Internal proxy states map (proxyId -> state) */
+	private states;
+	/** Current index for sequential rotation */
+	private currentIndex;
+	/** Request counter for current proxy (sequential rotation) */
+	private currentProxyRequests;
+	/** Last selected proxy (for rotation tracking) */
+	private lastSelectedProxy;
+	/** Cooldown timers map (proxyId -> timerId) */
+	private cooldownTimers;
+	/** Total requests through manager */
+	private _totalRequests;
+	/** Total successful requests */
+	private _totalSuccesses;
+	/** Total failed requests */
+	private _totalFailures;
+	/** Proxy hooks */
+	hooks: ProxyHooks;
+	/**
+	 * Create a new ProxyManager instance
+	 * @param config - Proxy manager configuration
+	 */
+	constructor(config: ProxyManagerConfig);
+	/**
+	 * Create initial state for a proxy
+	 */
+	private createInitialState;
+	/**
+	 * Check if a URL should use proxy based on whitelist/blacklist
+	 * @param url - The request URL to check
+	 * @returns true if URL should use proxy, false if should go direct
+	 */
+	shouldProxy(url: string): boolean;
+	/**
+	 * Match a URL against a pattern
+	 */
+	private matchPattern;
+	/**
+	 * Get active proxies (not disabled)
+	 */
+	getActive(): ProxyInfo[];
+	/**
+	 * Get disabled proxies
+	 */
+	getDisabled(): ProxyInfo[];
+	/**
+	 * Get proxies in cooldown
+	 */
+	getCooldown(): ProxyInfo[];
+	/**
+	 * Process expired cooldowns and re-enable proxies
+	 */
+	private processExpiredCooldowns;
+	/**
+	 * Get next proxy based on rotation strategy
+	 * @param url - The request URL (for whitelist/blacklist checking)
+	 * @returns Selected proxy or null if should go direct
+	 */
+	next(url: string): ProxyInfo | null;
+	/**
+	 * Get detailed selection result with reason
+	 * @param url - The request URL
+	 * @returns Selection result with proxy and reason
+	 */
+	select(url: string): ProxySelectionResult;
+	/**
+	 * Select proxy based on rotation strategy
+	 */
+	private selectProxy;
+	/**
+	 * Report a successful request through a proxy
+	 * @param proxy - The proxy that succeeded
+	 */
+	reportSuccess(proxy: ProxyInfo): void;
+	/**
+	 * Report a failed request through a proxy
+	 * @param proxy - The proxy that failed
+	 * @param error - The error that occurred
+	 * @param url - Optional URL for hook context
+	 */
+	reportFailure(proxy: ProxyInfo, error: Error, url?: string): void;
+	/**
+	 * Disable a proxy from the pool
+	 * @param proxy - The proxy to disable
+	 * @param reason - Reason for disabling
+	 */
+	disableProxy(proxy: ProxyInfo, reason?: "dead" | "limit-reached" | "manual"): void;
+	/**
+	 * Enable a previously disabled proxy
+	 * @param proxy - The proxy to enable
+	 * @param reason - Reason for enabling
+	 */
+	enableProxy(proxy: ProxyInfo, reason?: "cooldown-expired" | "manual"): void;
+	/**
+	 * Add proxies to the pool
+	 * @param proxies - Proxies to add
+	 */
+	add(proxies: ProxyInfo | ProxyInfo[]): void;
+	/**
+	 * Remove proxies from the pool
+	 * @param proxies - Proxies to remove
+	 */
+	remove(proxies: ProxyInfo | ProxyInfo[]): void;
+	/**
+	 * Reset all proxies - re-enable all and reset counters
+	 */
+	reset(): void;
+	/**
+	 * Get current status of all proxies
+	 */
+	getStatus(): ProxyManagerStatus;
+	/**
+	 * Get state for a specific proxy
+	 * @param proxy - The proxy to get state for
+	 */
+	getProxyState(proxy: ProxyInfo): ProxyState | undefined;
+	/**
+	 * Check if any proxies are available
+	 */
+	hasAvailableProxies(): boolean;
+	/**
+	 * Destroy the manager and cleanup timers
+	 */
+	destroy(): void;
+	private runBeforeProxySelectHooksSync;
+	private runAfterProxySelectHooksSync;
+	private runBeforeProxyErrorHooksSync;
+	private runAfterProxyErrorHooksSync;
+	private runAfterProxyRotateHooks;
+	private runAfterProxyDisableHooks;
+	private runAfterProxyEnableHooks;
+}
 export type queueOptions = Options$1<PriorityQueue, QueueAddOptions>;
 export interface CacheConfig {
 	/** Response cache configuration */
@@ -2445,6 +2932,35 @@ export interface RezoDefaultOptions {
 	 * DNS cache defaults: 1 min TTL, 1000 entries
 	 */
 	cache?: CacheOption;
+	/**
+	 * Proxy manager for advanced proxy rotation and pool management
+	 * - Provide a `ProxyManager` instance for full control
+	 * - Or provide `ProxyManagerConfig` to auto-create internally
+	 *
+	 * Note: ProxyManager overrides `proxy` option when set.
+	 * Use `useProxyManager: false` per-request to bypass.
+	 *
+	 * @example
+	 * ```typescript
+	 * // With config (auto-creates ProxyManager)
+	 * const client = new Rezo({
+	 *   proxyManager: {
+	 *     rotation: 'random',
+	 *     proxies: [
+	 *       { protocol: 'socks5', host: '127.0.0.1', port: 1080 },
+	 *       { protocol: 'http', host: 'proxy.example.com', port: 8080 }
+	 *     ],
+	 *     whitelist: ['api.example.com'],
+	 *     autoDisableDeadProxies: true
+	 *   }
+	 * });
+	 *
+	 * // With ProxyManager instance
+	 * const pm = new ProxyManager({ rotation: 'sequential', proxies: [...] });
+	 * const client = new Rezo({ proxyManager: pm });
+	 * ```
+	 */
+	proxyManager?: ProxyManager | ProxyManagerConfig;
 }
 export interface httpAdapterOverloads {
 	request<T = any>(options: RezoRequestOptions): Promise<RezoResponse<T>>;
@@ -3305,7 +3821,14 @@ declare class Rezo {
 	readonly dnsCache?: DNSCache;
 	/** The adapter function used for HTTP requests */
 	private readonly adapter;
+	/** Proxy manager for advanced proxy rotation and pool management */
+	private readonly _proxyManager;
 	constructor(config?: RezoDefaultOptions, adapter?: AdapterFunction);
+	/**
+	 * Get the ProxyManager instance (if configured)
+	 * @returns ProxyManager instance or null
+	 */
+	get proxyManager(): ProxyManager | null;
 	/**
 	 * Clear all caches (response and DNS)
 	 */

package/dist/entries/crawler.cjs

@@ -1,5 +1,5 @@
-const _mod_0hj10x = require('../plugin/crawler.cjs');
-exports.Crawler = _mod_0hj10x.Crawler;;
-const _mod_mxmkoz = require('../plugin/crawler-options.cjs');
-exports.CrawlerOptions = _mod_mxmkoz.CrawlerOptions;
-exports.Domain = _mod_mxmkoz.Domain;;
+const _mod_9syr2y = require('../plugin/crawler.cjs');
+exports.Crawler = _mod_9syr2y.Crawler;;
+const _mod_xywryj = require('../plugin/crawler-options.cjs');
+exports.CrawlerOptions = _mod_xywryj.CrawlerOptions;
+exports.Domain = _mod_xywryj.Domain;;

package/dist/index.cjs

@@ -1,19 +1,21 @@
-const _mod_7sze83 = require('./core/rezo.cjs');
-exports.Rezo = _mod_7sze83.Rezo;
-exports.createRezoInstance = _mod_7sze83.createRezoInstance;
-exports.createDefaultInstance = _mod_7sze83.createDefaultInstance;;
-const _mod_j9i84j = require('./errors/rezo-error.cjs');
-exports.RezoError = _mod_j9i84j.RezoError;
-exports.RezoErrorCode = _mod_j9i84j.RezoErrorCode;;
-const _mod_y5piv0 = require('./utils/headers.cjs');
-exports.RezoHeaders = _mod_y5piv0.RezoHeaders;;
-const _mod_l0prwp = require('./utils/form-data.cjs');
-exports.RezoFormData = _mod_l0prwp.RezoFormData;;
-const _mod_t9pqxu = require('./utils/cookies.cjs');
-exports.RezoCookieJar = _mod_t9pqxu.RezoCookieJar;;
-const _mod_7d3hfy = require('./core/hooks.cjs');
-exports.createDefaultHooks = _mod_7d3hfy.createDefaultHooks;
-exports.mergeHooks = _mod_7d3hfy.mergeHooks;;
+const _mod_li4oo6 = require('./core/rezo.cjs');
+exports.Rezo = _mod_li4oo6.Rezo;
+exports.createRezoInstance = _mod_li4oo6.createRezoInstance;
+exports.createDefaultInstance = _mod_li4oo6.createDefaultInstance;;
+const _mod_g7vumm = require('./errors/rezo-error.cjs');
+exports.RezoError = _mod_g7vumm.RezoError;
+exports.RezoErrorCode = _mod_g7vumm.RezoErrorCode;;
+const _mod_lcvlqo = require('./utils/headers.cjs');
+exports.RezoHeaders = _mod_lcvlqo.RezoHeaders;;
+const _mod_vdm8pb = require('./utils/form-data.cjs');
+exports.RezoFormData = _mod_vdm8pb.RezoFormData;;
+const _mod_zocq9d = require('./utils/cookies.cjs');
+exports.RezoCookieJar = _mod_zocq9d.RezoCookieJar;;
+const _mod_uxqfdf = require('./core/hooks.cjs');
+exports.createDefaultHooks = _mod_uxqfdf.createDefaultHooks;
+exports.mergeHooks = _mod_uxqfdf.mergeHooks;;
+const _mod_ztg1xc = require('./proxy/manager.cjs');
+exports.ProxyManager = _mod_ztg1xc.ProxyManager;;
 const { RezoError } = require('./errors/rezo-error.cjs');
 const isRezoError = exports.isRezoError = RezoError.isRezoError;
 const Cancel = exports.Cancel = RezoError;