create-request 0.0.1-beta.23 → 0.0.1-beta.24

package/dist/library/index.esm.js

@@ -48,18 +48,6 @@ var RedirectMode;
     RedirectMode["FOLLOW"] = "follow";
     RedirectMode["MANUAL"] = "manual";
 })(RedirectMode || (RedirectMode = {}));
-/**
- * Enum for cache modes
- */
-var CacheMode;
-(function (CacheMode) {
-    CacheMode["DEFAULT"] = "default";
-    CacheMode["RELOAD"] = "reload";
-    CacheMode["NO_STORE"] = "no-store";
-    CacheMode["NO_CACHE"] = "no-cache";
-    CacheMode["FORCE_CACHE"] = "force-cache";
-    CacheMode["ONLY_IF_CACHED"] = "only-if-cached";
-})(CacheMode || (CacheMode = {}));
 /**
  * Enum for cookie SameSite policies
  */
@@ -91,14 +79,108 @@ var ReferrerPolicy;
     ReferrerPolicy["ORIGIN_WHEN_CROSS_ORIGIN"] = "origin-when-cross-origin";
     ReferrerPolicy["NO_REFERRER_WHEN_DOWNGRADE"] = "no-referrer-when-downgrade";
     ReferrerPolicy["STRICT_ORIGIN_WHEN_CROSS_ORIGIN"] = "strict-origin-when-cross-origin";
-})(ReferrerPolicy || (ReferrerPolicy = {}));/**
+})(ReferrerPolicy || (ReferrerPolicy = {}));
+
+class RequestError extends Error {
+    constructor(message, url, method, options = {}) {
+        super(message);
+        this.name = "RequestError";
+        this.url = url;
+        this.method = method;
+        this.status = options.status;
+        this.response = options.response;
+        this.isTimeout = options.isTimeout;
+        this.isAborted = options.isAborted;
+        // For better stack traces in modern environments
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, RequestError);
+        }
+        // Maintains proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, RequestError.prototype);
+    }
+    /**
+     * Static methods for creating specific types of RequestError
+     */
+    static timeout(url, method, timeoutMs) {
+        return new RequestError(`Timeout: ${timeoutMs}ms`, url, method, {
+            isTimeout: true,
+        });
+    }
+    static fromResponse(response, url, method) {
+        return new RequestError(`HTTP ${response.status}`, url, method, {
+            status: response.status,
+            response,
+        });
+    }
+    static networkError(url, method, originalError) {
+        // Provide more descriptive error messages for common network errors
+        let message = originalError.message;
+        // Check for Node.js error codes (e.g., from undici/dns errors)
+        const errorCode = originalError.code;
+        const errorName = originalError.name;
+        const stack = originalError.stack || "";
+        const errorMessageLower = message.toLowerCase();
+        // Check for timeout errors (Node.js/undici TimeoutError)
+        const isTimeoutError = errorName === "TimeoutError" ||
+            errorMessageLower.includes("timeout") ||
+            errorMessageLower.includes("aborted due to timeout") ||
+            errorCode === "ETIMEDOUT" ||
+            stack.includes("TimeoutError") ||
+            stack.includes("timeout");
+        // If the error message is generic "fetch failed", provide more context
+        if (message === "fetch failed" || message === "Failed to fetch") {
+            // Check for DNS resolution errors
+            const isDnsError = errorCode === "ENOTFOUND" ||
+                errorCode === "EAI_AGAIN" ||
+                errorCode === "EAI_NODATA" ||
+                stack.includes("getaddrinfo") ||
+                stack.includes("ENOTFOUND") ||
+                stack.includes("EAI_AGAIN");
+            // Check for connection errors (but not timeout errors)
+            const isConnectionError = !isTimeoutError && (errorCode === "ECONNREFUSED" || errorCode === "ECONNRESET" || stack.includes("ECONNREFUSED") || stack.includes("connect"));
+            if (isTimeoutError) {
+                message = `Network error: Request timeout for ${url}`;
+            }
+            else if (isDnsError) {
+                message = `Network error: Unable to resolve hostname for ${url}`;
+            }
+            else if (isConnectionError) {
+                message = `Network error: Connection refused for ${url}`;
+            }
+            else {
+                message = `Network error: Failed to fetch ${url}`;
+            }
+        }
+        const error = new RequestError(message, url, method, {
+            ...(isTimeoutError ? { isTimeout: true } : {}),
+        });
+        // Create a proper RequestError stack trace, but append the original stack for debugging
+        // This way Node.js will show "RequestError: ..." instead of "TypeError: ..."
+        if (originalError.stack) {
+            // Get the current stack (which will start with RequestError)
+            const currentStack = error.stack || "";
+            // Append the original error's stack as "Caused by:" for debugging context
+            error.stack = `${currentStack}\n\nCaused by: ${originalError.stack}`;
+        }
+        return error;
+    }
+    static abortError(url, method) {
+        return new RequestError("Aborted", url, method, {
+            isAborted: true,
+        });
+    }
+}
+
+/**
  * Wrapper for HTTP responses with methods to transform the response data
  * Provides caching and conversion between different response formats.
  */
 class ResponseWrapper {
-    constructor(response) {
+    constructor(response, url, method) {
         this.bodyUsed = false;
         this.response = response;
+        this.url = url;
+        this.method = method;
     }
     // Wrapper properties
     get status() {
@@ -135,19 +217,43 @@ class ResponseWrapper {
             // If we already have text, try to parse it as JSON
             if (this.textCache !== undefined) {
                 try {
-                    // Fix unsafe assignment by explicitly casting to unknown first
-                    this.jsonCache = JSON.parse(this.textCache);
-                    return this.jsonCache;
+                    const parsed = JSON.parse(this.textCache);
+                    this.jsonCache = parsed;
+                    return parsed;
                 }
                 catch (e) {
-                    throw new Error("Cannot parse cached text as JSON");
+                    const errorMessage = e instanceof Error ? e.message : String(e);
+                    if (this.url && this.method) {
+                        throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url, this.method, {
+                            response: this.response,
+                        });
+                    }
+                    throw new Error(`Invalid JSON: ${errorMessage}`);
                 }
             }
-            throw new Error("Response body has already been consumed in a different format");
+            if (this.url && this.method) {
+                throw new RequestError("Body already consumed", this.url, this.method, {
+                    response: this.response,
+                });
+            }
+            throw new Error("Body already consumed");
         }
         this.bodyUsed = true;
-        this.jsonCache = (await this.response.json());
-        return this.jsonCache;
+        try {
+            const parsed = await this.response.json();
+            this.jsonCache = parsed;
+            return parsed;
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            if (this.url && this.method) {
+                throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url, this.method, {
+                    status: this.response.status,
+                    response: this.response,
+                });
+            }
+            throw e;
+        }
     }
     /**
      * Get the response body as text
@@ -172,14 +278,42 @@ class ResponseWrapper {
             }
             // If we have blob, convert to text
             if (this.blobCache !== undefined) {
-                this.textCache = await this.blobCache.text();
-                return this.textCache;
+                try {
+                    this.textCache = await this.blobCache.text();
+                    return this.textCache;
+                }
+                catch (e) {
+                    const errorMessage = e instanceof Error ? e.message : String(e);
+                    if (this.url && this.method) {
+                        throw new RequestError(`Cannot convert to text: ${errorMessage}`, this.url, this.method, {
+                            response: this.response,
+                        });
+                    }
+                    throw e;
+                }
             }
-            throw new Error("Response body has already been consumed in a format that cannot be converted to text");
+            if (this.url && this.method) {
+                throw new RequestError("Cannot convert to text", this.url, this.method, {
+                    response: this.response,
+                });
+            }
+            throw new Error("Cannot convert to text");
         }
         this.bodyUsed = true;
-        this.textCache = await this.response.text();
-        return this.textCache;
+        try {
+            this.textCache = await this.response.text();
+            return this.textCache;
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            if (this.url && this.method) {
+                throw new RequestError(`Read failed: ${errorMessage}`, this.url, this.method, {
+                    status: this.response.status,
+                    response: this.response,
+                });
+            }
+            throw e;
+        }
     }
     /**
      * Get the response body as a Blob
@@ -203,46 +337,28 @@ class ResponseWrapper {
                 this.blobCache = new Blob([this.textCache], { type: "text/plain" });
                 return this.blobCache;
             }
-            throw new Error("Response body has already been consumed in a format that cannot be converted to Blob");
+            if (this.url && this.method) {
+                throw new RequestError("Cannot convert to Blob", this.url, this.method, {
+                    response: this.response,
+                });
+            }
+            throw new Error("Cannot convert to Blob");
         }
         this.bodyUsed = true;
-        this.blobCache = await this.response.blob();
-        return this.blobCache;
-    }
-    /**
-     * Get the response body as an ArrayBuffer
-     * Caches the result for subsequent calls. Attempts to convert from text or Blob
-     * if the body has already been consumed in those formats.
-     *
-     * @returns The response as an ArrayBuffer
-     * @throws Error if the response has already been consumed in an incompatible format
-     *
-     * @example
-     * const buffer = await response.getArrayBuffer();
-     */
-    async getArrayBuffer() {
-        if (this.arrayBufferCache !== undefined) {
-            return this.arrayBufferCache;
+        try {
+            this.blobCache = await this.response.blob();
+            return this.blobCache;
         }
-        if (this.bodyUsed) {
-            // If we have text, convert to ArrayBuffer
-            if (this.textCache !== undefined) {
-                const encoder = new TextEncoder();
-                // Fix ArrayBufferLike by explicitly casting to ArrayBuffer
-                const uint8Array = encoder.encode(this.textCache);
-                this.arrayBufferCache = uint8Array.buffer;
-                return this.arrayBufferCache;
-            }
-            // If we have blob, convert to ArrayBuffer
-            if (this.blobCache !== undefined) {
-                this.arrayBufferCache = await this.blobCache.arrayBuffer();
-                return this.arrayBufferCache;
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            if (this.url && this.method) {
+                throw new RequestError(`Read failed: ${errorMessage}`, this.url, this.method, {
+                    status: this.response.status,
+                    response: this.response,
+                });
             }
-            throw new Error("Response body has already been consumed in a format that cannot be converted to ArrayBuffer");
+            throw e;
         }
-        this.bodyUsed = true;
-        this.arrayBufferCache = await this.response.arrayBuffer();
-        return this.arrayBufferCache;
     }
     /**
      * Get the raw response body as a ReadableStream
@@ -260,413 +376,66 @@ class ResponseWrapper {
      */
     getBody() {
         if (this.bodyUsed) {
-            throw new Error("Response body has already been consumed");
+            if (this.url && this.method) {
+                throw new RequestError("Body already consumed", this.url, this.method, {
+                    response: this.response,
+                });
+            }
+            throw new Error("Body already consumed");
         }
         this.bodyUsed = true;
         return this.response.body;
     }
-}/**
- * Create a memory storage provider using Map
- * This provider stores data in memory and is cleared when the application restarts.
- *
- * @returns A storage provider using an in-memory Map
- *
- * @example
- * const storage = createMemoryStorage();
- * storage.set("key", "value");
- */
-function createMemoryStorage() {
-    const store = new Map();
-    return {
-        get(key) {
-            return store.get(key) || null;
-        },
-        set(key, value) {
-            store.set(key, value);
-        },
-        has(key) {
-            return store.has(key);
-        },
-        delete(key) {
-            store.delete(key);
-        },
-        clear() {
-            store.clear();
-        },
-    };
-}
-/**
- * Create a localStorage-based storage provider
- * This provider persists data between browser sessions.
- *
- * @returns A storage provider using localStorage
- * @throws Console warnings if localStorage is not available or storage quota is exceeded
- *
- * @example
- * const storage = createLocalStorageStorage();
- * storage.set("key", "value");
- */
-function createLocalStorageStorage() {
-    return {
-        get(key) {
-            if (typeof localStorage === "undefined")
-                return null;
-            return localStorage.getItem(key);
-        },
-        set(key, value) {
-            if (typeof localStorage === "undefined")
-                return;
-            try {
-                localStorage.setItem(key, value);
-            }
-            catch (e) {
-                // Handle quota exceeded errors
-                console.warn("Cache storage quota exceeded, clearing cache");
-                void this.clear();
-                try {
-                    localStorage.setItem(key, value);
-                }
-                catch (e) {
-                    console.error("Failed to set cache item even after clearing cache");
-                }
-            }
-        },
-        has(key) {
-            if (typeof localStorage === "undefined")
-                return false;
-            return localStorage.getItem(key) !== null;
-        },
-        delete(key) {
-            if (typeof localStorage === "undefined")
-                return;
-            localStorage.removeItem(key);
-        },
-        clear() {
-            if (typeof localStorage === "undefined")
-                return;
-            localStorage.clear();
-        },
-    };
-}
-/**
- * Create a sessionStorage-based storage provider
- * This provider persists data only for the current browser session.
- *
- * @returns A storage provider using sessionStorage
- * @throws Console warnings if sessionStorage is not available or storage quota is exceeded
- *
- * @example
- * const storage = createSessionStorageStorage();
- * storage.set("key", "value");
- */
-function createSessionStorageStorage() {
-    return {
-        get(key) {
-            if (typeof sessionStorage === "undefined")
-                return null;
-            return sessionStorage.getItem(key);
-        },
-        set(key, value) {
-            if (typeof sessionStorage === "undefined")
-                return;
-            try {
-                sessionStorage.setItem(key, value);
-            }
-            catch (e) {
-                // Handle quota exceeded errors
-                console.warn("Cache storage quota exceeded, clearing cache");
-                void this.clear();
-                try {
-                    sessionStorage.setItem(key, value);
-                }
-                catch (e) {
-                    console.error("Failed to set cache item even after clearing cache");
-                }
-            }
-        },
-        has(key) {
-            if (typeof sessionStorage === "undefined")
-                return false;
-            return sessionStorage.getItem(key) !== null;
-        },
-        delete(key) {
-            if (typeof sessionStorage === "undefined")
-                return;
-            sessionStorage.removeItem(key);
-        },
-        clear() {
-            if (typeof sessionStorage === "undefined")
-                return;
-            sessionStorage.clear();
-        },
-    };
-}
-/**
- * Create a storage provider from cache options
- * Selects the appropriate storage implementation based on the provided options.
- * Falls back to memory storage if no suitable storage is found.
- *
- * @param options - Cache configuration options
- * @returns A storage provider based on the options
- *
- * @example
- * const storage = createStorageProvider({ storage: localStorage });
- */
-function createStorageProvider(options) {
-    const { storage } = options || {};
-    if (!storage) {
-        // Default to memory storage
-        return createMemoryStorage();
-    }
-    // Check if storage is already a StorageProvider
-    if (typeof storage.get === "function" && typeof storage.set === "function") {
-        return storage;
-    }
-    // Check if it's localStorage or sessionStorage
-    if (storage === localStorage) {
-        return createLocalStorageStorage();
-    }
-    if (storage === sessionStorage) {
-        return createSessionStorageStorage();
-    }
-    // Check if it's a Map
-    if (storage instanceof Map) {
-        return {
-            get(key) {
-                return storage.get(key) || null;
-            },
-            set(key, value, _ttl) {
-                storage.set(key, value);
-            },
-            has(key) {
-                return storage.has(key);
-            },
-            delete(key) {
-                storage.delete(key);
-            },
-            clear() {
-                storage.clear();
-            },
-        };
-    }
-    // Default to memory storage
-    console.warn("Unsupported storage type, falling back to memory storage");
-    return createMemoryStorage();
-}/**
- * Parse size strings like "10MB" into bytes
- * Supports KB, MB, and GB units. If no unit is specified, assumes bytes.
- *
- * @param size - Size as number (bytes) or string with units (e.g., "5MB")
- * @returns Size in bytes
- */
-function parseSize(size) {
-    var _a;
-    if (typeof size === "number")
-        return size;
-    const match = size.match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB)?$/i);
-    if (!match)
-        return 0;
-    const num = parseFloat(match[1]);
-    const unit = (_a = match[2]) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-    switch (unit) {
-        case "KB":
-            return num * 1024;
-        case "MB":
-            return num * 1024 * 1024;
-        case "GB":
-            return num * 1024 * 1024 * 1024;
-        default:
-            return num;
-    }
-}/**
- * Cache manager that handles storage operations
- * Provides methods for storing, retrieving, and managing cached API responses.
- */
-class CacheManager {
-    constructor(options = {}) {
-        this.entryCount = 0;
-        this.totalSize = 0;
-        this.options = options;
-        this.storage = createStorageProvider(options);
-    }
     /**
-     * Generate a cache key based on request details
-     * Keys can vary based on URL, method, headers, and request body.
+     * Extract specific data using a selector function
+     * If no selector is provided, returns the full JSON response.
      *
-     * @param url - The request URL
-     * @param method - The HTTP method
-     * @param headers - Request headers that might affect caching
-     * @param body - Request body for non-GET requests
-     * @returns A unique cache key string
+     * @param selector - Optional function to extract and transform data
+     * @returns A promise that resolves to the selected data
      *
      * @example
-     * const key = cacheManager.generateKey("/api/users", "GET", { "Accept": "application/json" });
-     */
-    generateKey(url, method, headers, body) {
-        // Use custom key generator if provided
-        if (this.options.keyGenerator) {
-            const customKey = this.options.keyGenerator(url, method, headers, body);
-            return this.options.keyPrefix ? `${this.options.keyPrefix}:${customKey}` : customKey;
-        }
-        // Default key generation
-        let key = `${method}:${url}`;
-        // Add vary headers to key if specified
-        if (this.options.varyByHeaders && headers) {
-            const varyHeaders = {};
-            this.options.varyByHeaders.forEach(header => {
-                const normalizedHeader = header.toLowerCase();
-                // Find the header in case-insensitive way
-                Object.keys(headers).forEach(h => {
-                    if (h.toLowerCase() === normalizedHeader) {
-                        varyHeaders[normalizedHeader] = headers[h];
-                    }
-                });
-            });
-            if (Object.keys(varyHeaders).length > 0) {
-                key += `:${JSON.stringify(varyHeaders)}`;
-            }
-        }
-        // Include body in cache key for non-GET requests if it's a simple value
-        if (method !== "GET" && body !== undefined && body !== null) {
-            try {
-                if (typeof body === "string" || typeof body === "number" || typeof body === "boolean") {
-                    key += `:${String(body)}`;
-                }
-                else if (typeof body === "object") {
-                    key += `:${JSON.stringify(body)}`;
-                }
-            }
-            catch (e) {
-                console.warn("Failed to stringify request body for cache key");
-            }
-        }
-        // Add prefix if specified
-        return this.options.keyPrefix ? `${this.options.keyPrefix}:${key}` : key;
-    }
-    /**
-     * Get a cached value by key
-     * Checks if the entry exists and isn't expired before returning it.
+     * // Get full response
+     * const data = await response.getData();
      *
-     * @param key - The cache key to retrieve
-     * @returns The cached entry or null if not found or expired
-     *
-     * @example
-     * const entry = await cacheManager.get("GET:/api/users");
+     * // Extract specific data
+     * const users = await response.getData(data => data.results.users);
      */
-    async get(key) {
-        const value = await Promise.resolve(this.storage.get(key));
-        if (!value)
-            return null;
+    async getData(selector) {
         try {
-            const entry = JSON.parse(value);
-            // Check if the entry has expired
-            if (entry.expiry && entry.expiry < Date.now()) {
-                await Promise.resolve(this.storage.delete(key));
-                return null;
-            }
-            return entry;
-        }
-        catch (e) {
-            // If we can't parse the cached value, remove it
-            await Promise.resolve(this.storage.delete(key));
-            return null;
+            const data = await this.getJson();
+            // If no selector is provided, return the raw JSON data
+            if (!selector)
+                return data;
+            // Apply the selector if provided
+            return selector(data);
         }
-    }
-    /**
-     * Store a value in the cache
-     * Enforces size and entry count limits if configured.
-     *
-     * @param key - The cache key
-     * @param value - The value to cache
-     * @param headers - Response headers to store with the cached value
-     * @returns Promise that resolves when caching is complete
-     *
-     * @example
-     * await cacheManager.set("GET:/api/users", userData, { "Content-Type": "application/json" });
-     */
-    async set(key, value, headers) {
-        const now = Date.now();
-        const ttl = this.options.ttl;
-        const entry = {
-            value,
-            timestamp: now,
-            expiry: ttl ? now + ttl : null,
-            headers,
-        };
-        const serialized = JSON.stringify(entry);
-        // Check size constraints if applicable
-        if (this.options.maxSize) {
-            const maxBytes = parseSize(this.options.maxSize);
-            const entrySize = new TextEncoder().encode(serialized).length;
-            // If a single entry exceeds the max size, reject it without clearing the cache
-            if (entrySize > maxBytes) {
-                console.warn(`Cache entry size (${entrySize} bytes) exceeds maximum cache size (${maxBytes} bytes)`);
-                return;
+        catch (error) {
+            // If it's already a RequestError, re-throw it
+            if (error instanceof RequestError) {
+                throw error;
             }
-            // Only clear if adding this entry would exceed the total limit
-            if (this.totalSize + entrySize > maxBytes) {
-                // Simple strategy: clear everything
-                // A more sophisticated strategy would remove oldest entries first
-                await Promise.resolve(this.storage.clear());
-                this.totalSize = 0;
-                this.entryCount = 0;
+            // Enhance selector errors with context
+            if (selector) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (this.url && this.method) {
+                    throw new RequestError(`Data selector failed: ${errorMessage}`, this.url, this.method, {
+                        response: this.response,
+                    });
+                }
+                throw new Error(`Data selector failed: ${errorMessage}`);
             }
-            this.totalSize += entrySize;
-        }
-        // Check max entries constraint
-        if (this.options.maxEntries) {
-            this.entryCount++;
-            if (this.entryCount > this.options.maxEntries) {
-                // Simple strategy: clear everything
-                // A more sophisticated strategy would use LRU cache
-                await Promise.resolve(this.storage.clear());
-                this.entryCount = 1;
+            // If we get here and it's not a RequestError, wrap it
+            // This should rarely happen as getJson() should throw RequestError
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            if (this.url && this.method) {
+                throw RequestError.networkError(this.url, this.method, errorObj);
             }
+            throw errorObj;
         }
-        // Pass ttl to storage provider if available
-        await Promise.resolve(this.storage.set(key, serialized, ttl));
     }
-    /**
-     * Check if a key exists in the cache
-     *
-     * @param key - The cache key to check
-     * @returns Promise that resolves to true if the key exists, false otherwise
-     *
-     * @example
-     * if (await cacheManager.has("GET:/api/users")) {
-     *   // Use cached value
-     * }
-     */
-    async has(key) {
-        return Promise.resolve(this.storage.has(key));
-    }
-    /**
-     * Delete a specific key from the cache
-     *
-     * @param key - The cache key to delete
-     * @returns Promise that resolves when deletion is complete
-     *
-     * @example
-     * await cacheManager.delete("GET:/api/users");
-     */
-    async delete(key) {
-        return Promise.resolve(this.storage.delete(key));
-    }
-    /**
-     * Clear the entire cache
-     * Resets internal counters for entry count and size.
-     *
-     * @returns Promise that resolves when the cache is cleared
-     *
-     * @example
-     * await cacheManager.clear();
-     */
-    async clear() {
-        this.entryCount = 0;
-        this.totalSize = 0;
-        return Promise.resolve(this.storage.clear());
-    }
-}class CookieUtils {
+}
+
+class CookieUtils {
     /**
      * Formats cookies for a request
      * @param cookies Object containing cookie name-value pairs or cookie options
@@ -688,42 +457,9 @@ class CacheManager {
         });
         return cookiePairs.join("; ");
     }
-}class RequestError extends Error {
-    constructor(message, url, method, options = {}) {
-        super(message);
-        this.name = "RequestError";
-        this.url = url;
-        this.method = method;
-        this.status = options.status;
-        this.response = options.response;
-        this.timeoutError = options.timeoutError;
-        // For better stack traces in modern environments
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, RequestError);
-        }
-        // Maintains proper prototype chain for instanceof checks
-        Object.setPrototypeOf(this, RequestError.prototype);
-    }
-    /**
-     * Static methods for creating specific types of RequestError
-     */
-    static timeout(url, method, timeoutMs) {
-        return new RequestError(`Request timed out after ${timeoutMs}ms`, url, method, {
-            timeoutError: true,
-        });
-    }
-    static fromResponse(response, url, method) {
-        return new RequestError(`Request failed with status ${response.status}`, url, method, {
-            status: response.status,
-            response,
-        });
-    }
-    static networkError(url, method, originalError) {
-        const error = new RequestError(`Network error: ${originalError.message}`, url, method);
-        error.stack = originalError.stack;
-        return error;
-    }
-}/**
+}
+
+/**
  * Utility class for CSRF token management
  */
 class CsrfUtils {
@@ -788,7 +524,9 @@ class CsrfUtils {
         // For shorter tokens (8-10 chars), just return true if we reached here
         return true;
     }
-}/**
+}
+
+/**
  * Global configuration for create-request
  */
 class Config {
@@ -800,6 +538,11 @@ class Config {
         this.csrfToken = null;
         this.enableAutoXsrf = true;
         this.enableAntiCsrf = true; // X-Requested-With header
+        // Interceptor configuration
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.errorInterceptors = [];
+        this.nextInterceptorId = 1;
     }
     /**
      * Get the singleton instance of the Config class
@@ -927,17 +670,136 @@ class Config {
      * @param enable - Whether to enable this feature
      * @returns The config instance for chaining
      */
-    setEnableAntiCsrf(enable) {
-        this.enableAntiCsrf = enable;
-        return this;
+    setEnableAntiCsrf(enable) {
+        this.enableAntiCsrf = enable;
+        return this;
+    }
+    /**
+     * Check if anti-CSRF protection is enabled
+     *
+     * @returns True if anti-CSRF protection is enabled
+     */
+    isAntiCsrfEnabled() {
+        return this.enableAntiCsrf;
+    }
+    /**
+     * Add a global request interceptor
+     * Request interceptors can modify the request configuration or return an early response
+     *
+     * @param interceptor - The request interceptor function
+     * @returns The interceptor ID for later removal
+     *
+     * @example
+     * const id = Config.getInstance().addRequestInterceptor((config) => {
+     *   config.headers['X-Custom'] = 'value';
+     *   return config;
+     * });
+     */
+    addRequestInterceptor(interceptor) {
+        const id = this.nextInterceptorId++;
+        this.requestInterceptors.push({ id, interceptor });
+        return id;
+    }
+    /**
+     * Add a global response interceptor
+     * Response interceptors can transform the response
+     *
+     * @param interceptor - The response interceptor function
+     * @returns The interceptor ID for later removal
+     *
+     * @example
+     * const id = Config.getInstance().addResponseInterceptor((response) => {
+     *   console.log('Response received:', response.status);
+     *   return response;
+     * });
+     */
+    addResponseInterceptor(interceptor) {
+        const id = this.nextInterceptorId++;
+        this.responseInterceptors.push({ id, interceptor });
+        return id;
+    }
+    /**
+     * Add a global error interceptor
+     * Error interceptors can handle or transform errors
+     *
+     * @param interceptor - The error interceptor function
+     * @returns The interceptor ID for later removal
+     *
+     * @example
+     * const id = Config.getInstance().addErrorInterceptor((error) => {
+     *   console.error('Request failed:', error);
+     *   throw error;
+     * });
+     */
+    addErrorInterceptor(interceptor) {
+        const id = this.nextInterceptorId++;
+        this.errorInterceptors.push({ id, interceptor });
+        return id;
+    }
+    /**
+     * Remove a request interceptor by its ID
+     *
+     * @param id - The interceptor ID returned from addRequestInterceptor
+     *
+     * @example
+     * Config.getInstance().removeRequestInterceptor(id);
+     */
+    removeRequestInterceptor(id) {
+        this.requestInterceptors = this.requestInterceptors.filter(item => item.id !== id);
+    }
+    /**
+     * Remove a response interceptor by its ID
+     *
+     * @param id - The interceptor ID returned from addResponseInterceptor
+     *
+     * @example
+     * Config.getInstance().removeResponseInterceptor(id);
+     */
+    removeResponseInterceptor(id) {
+        this.responseInterceptors = this.responseInterceptors.filter(item => item.id !== id);
+    }
+    /**
+     * Remove an error interceptor by its ID
+     *
+     * @param id - The interceptor ID returned from addErrorInterceptor
+     *
+     * @example
+     * Config.getInstance().removeErrorInterceptor(id);
+     */
+    removeErrorInterceptor(id) {
+        this.errorInterceptors = this.errorInterceptors.filter(item => item.id !== id);
+    }
+    /**
+     * Clear all interceptors (request, response, and error)
+     *
+     * @example
+     * Config.getInstance().clearInterceptors();
+     */
+    clearInterceptors() {
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.errorInterceptors = [];
+    }
+    /**
+     * Get all global request interceptors (in registration order)
+     * @internal
+     */
+    getRequestInterceptors() {
+        return this.requestInterceptors.map(item => item.interceptor);
+    }
+    /**
+     * Get all global response interceptors (in registration order)
+     * @internal
+     */
+    getResponseInterceptors() {
+        return this.responseInterceptors.map(item => item.interceptor);
     }
     /**
-     * Check if anti-CSRF protection is enabled
-     *
-     * @returns True if anti-CSRF protection is enabled
+     * Get all global error interceptors (in registration order)
+     * @internal
      */
-    isAntiCsrfEnabled() {
-        return this.enableAntiCsrf;
+    getErrorInterceptors() {
+        return this.errorInterceptors.map(item => item.interceptor);
     }
     /**
      * Reset all configuration options to their default values
@@ -954,20 +816,63 @@ class Config {
         this.xsrfCookieName = "XSRF-TOKEN";
         this.xsrfHeaderName = "X-XSRF-TOKEN";
         this.enableAutoXsrf = true;
+        this.clearInterceptors();
         return this;
     }
-}/**
+}
+
+/**
  * Base class with common functionality for all request types
  * Provides the core request building and execution capabilities.
  */
 class BaseRequest {
-    constructor() {
+    constructor(url) {
         this.requestOptions = {
             headers: {},
         };
         this.queryParams = new URLSearchParams();
         this.autoApplyCsrfProtection = true;
-        this.cacheEnabled = false;
+        // Per-request interceptors
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.errorInterceptors = [];
+        this.url = url;
+    }
+    /**
+     * Creates a fluent API for setting enum-based options
+     * Combines direct setter with convenience methods
+     */
+    createFluentSetter(optionName, options) {
+        const fluent = {};
+        // Create convenience methods for each enum value
+        Object.entries(options).forEach(([key, value]) => {
+            fluent[key] = () => {
+                this.requestOptions[optionName] = value;
+                return this;
+            };
+        });
+        // Create the callable setter
+        const callable = (value) => {
+            this.requestOptions[optionName] = value;
+            return this;
+        };
+        return Object.assign(callable, fluent);
+    }
+    validateUrl(url) {
+        if (!(url === null || url === void 0 ? void 0 : url.trim()))
+            throw new RequestError("URL cannot be empty", url, this.method);
+        if (url.includes("\0") || url.includes("\r") || url.includes("\n")) {
+            throw new RequestError("Invalid URL (control chars)", url, this.method);
+        }
+        const trimmed = url.trim();
+        if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+            try {
+                new URL(trimmed);
+            }
+            catch (_a) {
+                throw new RequestError(`Invalid URL: ${trimmed}`, trimmed, this.method);
+            }
+        }
     }
     /**
      * Add multiple HTTP headers to the request
@@ -982,9 +887,16 @@ class BaseRequest {
      * });
      */
     withHeaders(headers) {
+        // Filter out null and undefined values
+        const filteredHeaders = {};
+        Object.entries(headers).forEach(([key, value]) => {
+            if (value !== null && value !== undefined) {
+                filteredHeaders[key] = value;
+            }
+        });
         this.requestOptions.headers = {
-            ...this.requestOptions.headers,
-            ...headers,
+            ...this.getHeadersRecord(),
+            ...filteredHeaders,
         };
         return this;
     }
@@ -999,7 +911,11 @@ class BaseRequest {
      * request.withHeader('Accept', 'application/json');
      */
     withHeader(key, value) {
-        return this.withHeaders({ [key]: value });
+        // Ignore null and undefined values
+        if (value !== null && value !== undefined) {
+            return this.withHeaders({ [key]: value });
+        }
+        return this;
     }
     /**
      * Set a timeout for the request
@@ -1052,13 +968,18 @@ class BaseRequest {
         return this;
     }
     /**
-     * Sets the credentials policy for the request
-     * @param credentialsPolicy - Can be 'omit', 'same-origin', or 'include'
-     * @returns The instance for chaining
+     * Sets credentials policy - supports both direct call and fluent API
+     * @example
+     * request.withCredentials("include")
+     * request.withCredentials(CredentialsPolicy.INCLUDE)
+     * request.withCredentials.INCLUDE()
      */
-    withCredentials(credentialsPolicy = CredentialsPolicy.SAME_ORIGIN) {
-        this.requestOptions.credentials = credentialsPolicy;
-        return this;
+    get withCredentials() {
+        return this.createFluentSetter("credentials", {
+            INCLUDE: CredentialsPolicy.INCLUDE,
+            OMIT: CredentialsPolicy.OMIT,
+            SAME_ORIGIN: CredentialsPolicy.SAME_ORIGIN,
+        });
     }
     /**
      * Allows providing an external AbortController to cancel the request
@@ -1079,22 +1000,37 @@ class BaseRequest {
         return this;
     }
     /**
-     * Sets the referrer policy for the request
-     * @param policy - The referrer policy to use
-     * @returns The instance for chaining
+     * Sets referrer policy - supports both direct call and fluent API
+     * @example
+     * request.withReferrerPolicy("no-referrer")
+     * request.withReferrerPolicy(ReferrerPolicy.NO_REFERRER)
+     * request.withReferrerPolicy.NO_REFERRER()
      */
-    withReferrerPolicy(policy) {
-        this.requestOptions.referrerPolicy = policy;
-        return this;
+    get withReferrerPolicy() {
+        return this.createFluentSetter("referrerPolicy", {
+            ORIGIN: ReferrerPolicy.ORIGIN,
+            UNSAFE_URL: ReferrerPolicy.UNSAFE_URL,
+            SAME_ORIGIN: ReferrerPolicy.SAME_ORIGIN,
+            NO_REFERRER: ReferrerPolicy.NO_REFERRER,
+            STRICT_ORIGIN: ReferrerPolicy.STRICT_ORIGIN,
+            ORIGIN_WHEN_CROSS_ORIGIN: ReferrerPolicy.ORIGIN_WHEN_CROSS_ORIGIN,
+            NO_REFERRER_WHEN_DOWNGRADE: ReferrerPolicy.NO_REFERRER_WHEN_DOWNGRADE,
+            STRICT_ORIGIN_WHEN_CROSS_ORIGIN: ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
+        });
     }
     /**
-     * Sets the redirect policy for the request
-     * @param redirect - Can be 'follow', 'error', or 'manual'
-     * @returns The instance for chaining
+     * Sets redirect mode - supports both direct call and fluent API
+     * @example
+     * request.withRedirect("follow")
+     * request.withRedirect(RedirectMode.FOLLOW)
+     * request.withRedirect.FOLLOW()
      */
-    withRedirect(redirect) {
-        this.requestOptions.redirect = redirect;
-        return this;
+    get withRedirect() {
+        return this.createFluentSetter("redirect", {
+            FOLLOW: RedirectMode.FOLLOW,
+            ERROR: RedirectMode.ERROR,
+            MANUAL: RedirectMode.MANUAL,
+        });
     }
     /**
      * Sets the keepalive flag for the request
@@ -1106,13 +1042,18 @@ class BaseRequest {
         return this;
     }
     /**
-     * Sets the priority of the request
-     * @param priority - Can be 'high', 'low', or 'auto'
-     * @returns The instance for chaining
+     * Sets request priority - supports both direct call and fluent API
+     * @example
+     * request.withPriority("high")
+     * request.withPriority(RequestPriority.HIGH)
+     * request.withPriority.HIGH()
      */
-    withPriority(priority) {
-        this.requestOptions.priority = priority;
-        return this;
+    get withPriority() {
+        return this.createFluentSetter("priority", {
+            HIGH: RequestPriority.HIGH,
+            LOW: RequestPriority.LOW,
+            AUTO: RequestPriority.AUTO,
+        });
     }
     /**
      * Adds query parameters to the request URL
@@ -1150,13 +1091,19 @@ class BaseRequest {
         return this;
     }
     /**
-     * Sets the mode of the request
-     * @param mode - The mode for the request (cors, no-cors, same-origin, navigate)
-     * @returns The instance for chaining
+     * Sets request mode - supports both direct call and fluent API
+     * @example
+     * request.withMode("cors")
+     * request.withMode(RequestMode.CORS)
+     * request.withMode.CORS()
      */
-    withMode(mode) {
-        this.requestOptions.mode = mode;
-        return this;
+    get withMode() {
+        return this.createFluentSetter("mode", {
+            CORS: RequestMode.CORS,
+            NO_CORS: RequestMode.NO_CORS,
+            SAME_ORIGIN: RequestMode.SAME_ORIGIN,
+            NAVIGATE: RequestMode.NAVIGATE,
+        });
     }
     /**
      * Shorthand for setting the Content-Type header
@@ -1216,13 +1163,23 @@ class BaseRequest {
     withBearerToken(token) {
         return this.withAuthorization(`Bearer ${token}`);
     }
+    /**
+     * Safely get headers as a Record<string, string>
+     * @returns The headers object
+     */
+    getHeadersRecord() {
+        if (typeof this.requestOptions.headers === "object" && this.requestOptions.headers !== null) {
+            return this.requestOptions.headers;
+        }
+        return {};
+    }
     /**
      * Helper function to check for header presence in a case-insensitive way
-     * @param headers Headers object
      * @param headerName Header name to check
      * @returns Boolean indicating if the header exists (case-insensitive)
      */
-    hasHeader(headers, headerName) {
+    hasHeader(headerName) {
+        const headers = this.getHeadersRecord();
         return Object.keys(headers).some(key => key.toLowerCase() === headerName.toLowerCase());
     }
     /**
@@ -1235,8 +1192,7 @@ class BaseRequest {
         if (cookieEntries.length === 0) {
             return this;
         }
-        // Get current headers or initialize empty object
-        const currentHeaders = this.requestOptions.headers || {};
+        const currentHeaders = this.getHeadersRecord();
         // Get all existing cookie headers with different cases
         const cookieValues = [];
         const cookieHeaderKeys = [];
@@ -1305,127 +1261,178 @@ class BaseRequest {
         });
     }
     /**
-     * Configure request caching behavior
-     * When enabled, responses will be cached and reused for subsequent identical requests.
+     * Add a request interceptor for this specific request
+     * Request interceptors can modify the request configuration or return an early response
      *
-     * @param options - Cache configuration options
-     * @returns The request instance for chaining
+     * @param interceptor - The request interceptor function
+     * @returns The instance for chaining
      *
      * @example
-     * request.withCache({
-     *   ttl: 60000, // Cache for 1 minute
-     *   maxEntries: 100,
-     *   storage: localStorage
+     * request.withRequestInterceptor((config) => {
+     *   config.headers['X-Custom'] = 'value';
+     *   return config;
      * });
      */
-    withCache(options = {}) {
-        this.cacheEnabled = true;
-        this.cacheManager = new CacheManager(options);
+    withRequestInterceptor(interceptor) {
+        this.requestInterceptors.push(interceptor);
         return this;
     }
     /**
-     * Send the request to the specified URL
-     * This is the final method in the chain that executes the request.
+     * Add a response interceptor for this specific request
+     * Response interceptors can transform the response
      *
-     * @param url - The URL to send the request to
-     * @returns A promise with additional methods for processing the response
+     * @param interceptor - The response interceptor function
+     * @returns The instance for chaining
      *
      * @example
-     * const response = await request.sendTo('/api/users');
-     * const data = await response.getJson();
+     * request.withResponseInterceptor((response) => {
+     *   console.log('Status:', response.status);
+     *   return response;
+     * });
+     */
+    withResponseInterceptor(interceptor) {
+        this.responseInterceptors.push(interceptor);
+        return this;
+    }
+    /**
+     * Add an error interceptor for this specific request
+     * Error interceptors can handle or transform errors
+     *
+     * @param interceptor - The error interceptor function
+     * @returns The instance for chaining
+     *
+     * @example
+     * request.withErrorInterceptor((error) => {
+     *   console.error('Request failed:', error);
+     *   throw error;
+     * });
+     */
+    withErrorInterceptor(interceptor) {
+        this.errorInterceptors.push(interceptor);
+        return this;
+    }
+    /**
+     * Execute the request and return the ResponseWrapper
+     * This is the base method for getting the full response.
+     *
+     * @returns A promise that resolves to the ResponseWrapper
+     *
+     * @example
+     * const response = await request.getResponse();
+     * console.log(response.status);
+     */
+    async getResponse() {
+        const url = this.formatUrlWithQueryParams(this.url);
+        this.applyCsrfProtection();
+        const fetchOptions = {
+            ...this.requestOptions,
+            method: this.method,
+        };
+        return !this.requestOptions.retries ? this.executeRequest(url, fetchOptions) : this.executeWithRetries(url, fetchOptions);
+    }
+    /**
+     * Execute the request and parse the response as JSON
+     *
+     * @returns A promise that resolves to the parsed JSON data
+     *
+     * @example
+     * const users = await request.getJson<User[]>();
+     */
+    async getJson() {
+        const response = await this.getResponse();
+        return response.getJson();
+    }
+    /**
+     * Execute the request and get the response as text
+     *
+     * @returns A promise that resolves to the response text
+     *
+     * @example
+     * const text = await request.getText();
+     */
+    async getText() {
+        const response = await this.getResponse();
+        return response.getText();
+    }
+    /**
+     * Execute the request and get the response as a Blob
+     *
+     * @returns A promise that resolves to the response Blob
+     *
+     * @example
+     * const blob = await request.getBlob();
+     */
+    async getBlob() {
+        const response = await this.getResponse();
+        return response.getBlob();
+    }
+    /**
+     * Execute the request and get the response body as a ReadableStream
+     *
+     * @returns A promise that resolves to the response body stream
+     *
+     * @example
+     * const stream = await request.getBody();
+     */
+    async getBody() {
+        const response = await this.getResponse();
+        return response.getBody();
+    }
+    /**
+     * Execute the request and extract specific data using a selector function
+     * If no selector is provided, returns the full JSON response.
+     *
+     * @param selector - Optional function to extract and transform data
+     * @returns A promise that resolves to the selected data
+     *
+     * @example
+     * // Get full response
+     * const data = await request.getData();
+     *
+     * // Extract specific data
+     * const users = await request.getData(data => data.results.users);
      */
-    sendTo(url) {
-        // Format the URL with query parameters
-        url = this.formatUrlWithQueryParams(url);
-        // Apply automatic CSRF protection if enabled
-        if (this.autoApplyCsrfProtection) {
-            const config = Config.getInstance();
-            // Apply anti-CSRF headers if enabled
-            if (config.isAntiCsrfEnabled()) {
+    async getData(selector) {
+        const response = await this.getResponse();
+        return response.getData(selector);
+    }
+    /**
+     * Apply CSRF protection headers based on configuration
+     */
+    applyCsrfProtection() {
+        if (!this.autoApplyCsrfProtection)
+            return;
+        const config = Config.getInstance();
+        // Apply anti-CSRF headers if enabled
+        if (config.isAntiCsrfEnabled()) {
+            this.withHeaders({
+                "X-Requested-With": "XMLHttpRequest",
+            });
+        }
+        // Apply global CSRF token if set
+        const globalToken = config.getCsrfToken();
+        if (globalToken) {
+            const csrfHeaderName = config.getCsrfHeaderName();
+            const hasLocalToken = this.hasHeader("X-CSRF-Token") || this.hasHeader(csrfHeaderName);
+            if (!hasLocalToken) {
                 this.withHeaders({
-                    "X-Requested-With": "XMLHttpRequest",
+                    [csrfHeaderName]: globalToken,
                 });
             }
-            // Apply global CSRF token if set
-            const globalToken = config.getCsrfToken();
-            if (globalToken) {
-                // Check if local token exists using case-insensitive comparison
-                const headers = this.requestOptions.headers;
-                const csrfHeaderName = config.getCsrfHeaderName();
-                const hasLocalToken = this.hasHeader(headers, "X-CSRF-Token") || this.hasHeader(headers, csrfHeaderName);
+        }
+        // Check for XSRF token in cookies and send it as a header
+        if (config.isAutoXsrfEnabled() && typeof document !== "undefined") {
+            const xsrfToken = CsrfUtils.getTokenFromCookie(config.getXsrfCookieName());
+            if (xsrfToken && CsrfUtils.isValidToken(xsrfToken)) {
+                const xsrfHeaderName = config.getXsrfHeaderName();
+                const hasLocalToken = this.hasHeader("X-XSRF-TOKEN") || this.hasHeader(xsrfHeaderName);
                 if (!hasLocalToken) {
                     this.withHeaders({
-                        [csrfHeaderName]: globalToken,
+                        [xsrfHeaderName]: xsrfToken,
                     });
                 }
             }
-            // check for XSRF token in cookies and send it as a header
-            if (config.isAutoXsrfEnabled() && typeof document !== "undefined") {
-                const xsrfToken = CsrfUtils.getTokenFromCookie(config.getXsrfCookieName());
-                if (xsrfToken && CsrfUtils.isValidToken(xsrfToken)) {
-                    const headers = this.requestOptions.headers;
-                    const xsrfHeaderName = config.getXsrfHeaderName();
-                    const hasLocalToken = this.hasHeader(headers, "X-XSRF-TOKEN") || this.hasHeader(headers, xsrfHeaderName);
-                    if (!hasLocalToken) {
-                        this.withHeaders({
-                            [xsrfHeaderName]: xsrfToken,
-                        });
-                    }
-                }
-            }
-        }
-        // Cast the request options to RequestInit to ensure compatibility
-        const fetchOptions = {
-            ...this.requestOptions,
-            method: this.method,
-        };
-        // Create the base promise - handle caching if enabled
-        let basePromise;
-        if (this.cacheEnabled && this.cacheManager) {
-            const cacheKey = this.cacheManager.generateKey(url, this.method, this.requestOptions.headers, this.requestOptions.body);
-            basePromise = this.executeWithCache(url, fetchOptions, cacheKey);
-        }
-        else {
-            basePromise = !this.requestOptions.retries ? this.executeRequest(url, fetchOptions) : this.executeWithRetries(url, fetchOptions);
         }
-        const responsePromise = basePromise;
-        // Attach convenience methods that begin processing immediately
-        responsePromise.getJson = async () => {
-            return basePromise.then(response => response.getJson());
-        };
-        responsePromise.getText = async () => {
-            return basePromise.then(response => response.getText());
-        };
-        responsePromise.getBlob = async () => {
-            return basePromise.then(response => response.getBlob());
-        };
-        responsePromise.getArrayBuffer = async () => {
-            return basePromise.then(response => response.getArrayBuffer());
-        };
-        responsePromise.getBody = async () => {
-            return basePromise.then(response => response.getBody());
-        };
-        responsePromise.getData = async (selector) => {
-            try {
-                const data = await basePromise.then(response => response.getJson());
-                // If no selector is provided, return the raw JSON data
-                if (!selector)
-                    return data;
-                // Apply the selector if provided
-                return selector(data);
-            }
-            catch (error) {
-                // Always enhance the error with the original data
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                const enhancedError = new Error(`Data selector failed: ${errorMessage}. Original data: ${JSON.stringify(await basePromise.then(response => response.getJson()), null, 2)}`);
-                // Preserve the stack trace if available
-                if (error instanceof Error && error.stack) {
-                    enhancedError.stack = error.stack;
-                }
-                throw enhancedError;
-            }
-        };
-        return responsePromise;
     }
     /**
      * Formats the URL with any query parameters
@@ -1461,12 +1468,13 @@ class BaseRequest {
      */
     async executeWithRetries(url, fetchOptions) {
         const maxRetries = this.requestOptions.retries || 0;
+        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             try {
                 return await this.executeRequest(url, fetchOptions);
             }
             catch (error) {
-                const requestError = error instanceof RequestError ? error : RequestError.networkError(url, fetchOptions.method, error);
+                const requestError = error instanceof RequestError ? error : RequestError.networkError(url, method, error instanceof Error ? error : new Error(String(error)));
                 if (attempt >= maxRetries)
                     throw requestError;
                 if (this.requestOptions.onRetry) {
@@ -1475,121 +1483,286 @@ class BaseRequest {
             }
         }
         // This should never happen but is needed for type safety
-        throw new RequestError(`Max retries reached`, url, fetchOptions.method);
+        throw new RequestError(`Max retries reached`, url, method);
     }
-    async executeRequest(url, fetchOptions) {
-        // Create a request controller for timeout if needed, or use the provided one
-        const controller = this.abortController || new AbortController();
-        const { signal } = controller;
-        // Use the controller signal for the fetch request, but don't overwrite an existing signal
-        fetchOptions.signal = fetchOptions.signal || signal;
-        let timeoutId;
-        // Flag to track if abort was caused by our timeout
-        let abortedByTimeout = false;
-        // Handle timeout regardless of whether an external controller is provided
-        if (this.requestOptions.timeout) {
-            if (this.abortController) {
-                // If we have an external controller, create a separate timeout controller
-                // that won't interfere with the external one
-                // Use AbortSignal.timeout if available (modern browsers)
-                if (typeof AbortSignal.timeout === "function") {
-                    const timeoutSignal = AbortSignal.timeout(this.requestOptions.timeout);
-                    // Add event listener to propagate the abort to the main controller
-                    timeoutSignal.addEventListener("abort", () => {
-                        if (!controller.signal.aborted) {
-                            abortedByTimeout = true;
-                            controller.abort();
-                        }
-                    });
+    /**
+     * Run request interceptors in order: global interceptors first, then per-request
+     * @param configParam - The request configuration
+     * @returns Modified config or a Response to short-circuit
+     */
+    async runRequestInterceptors(configParam) {
+        const globalConfig = Config.getInstance();
+        const allInterceptors = [...globalConfig.getRequestInterceptors(), ...this.requestInterceptors];
+        let currentConfig = configParam;
+        for (let i = 0; i < allInterceptors.length; i++) {
+            try {
+                const result = await allInterceptors[i](currentConfig);
+                // If interceptor returns a Response, short-circuit
+                if (result instanceof Response) {
+                    return result;
+                }
+                currentConfig = result;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Use RequestError when we have request context
+                throw new RequestError(`Interceptor failed: ${errorMessage}`, currentConfig.url, currentConfig.method);
+            }
+        }
+        return currentConfig;
+    }
+    /**
+     * Run response interceptors in reverse order: per-request interceptors first, then global in reverse
+     * @param response - The response wrapper
+     * @returns Modified response wrapper
+     */
+    async runResponseInterceptors(response) {
+        const globalConfig = Config.getInstance();
+        const globalInterceptors = globalConfig.getResponseInterceptors();
+        // Per-request in order, then global in reverse
+        const allInterceptors = [...this.responseInterceptors, ...globalInterceptors.reverse()];
+        let currentResponse = response;
+        for (let i = 0; i < allInterceptors.length; i++) {
+            try {
+                currentResponse = await allInterceptors[i](currentResponse);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Use RequestError when we have response context (url/method from ResponseWrapper)
+                if (currentResponse.url && currentResponse.method) {
+                    throw new RequestError(`Interceptor failed: ${errorMessage}`, currentResponse.url, currentResponse.method);
+                }
+                // Fallback to generic Error if no context available (shouldn't happen in practice)
+                throw new Error(`Interceptor failed: ${errorMessage}`);
+            }
+        }
+        return currentResponse;
+    }
+    /**
+     * Run error interceptors in reverse order: per-request interceptors first, then global in reverse
+     * @param error - The error that occurred
+     * @returns Modified error or a ResponseWrapper to recover
+     */
+    async runErrorInterceptors(error) {
+        const globalConfig = Config.getInstance();
+        const globalInterceptors = globalConfig.getErrorInterceptors();
+        // Per-request in order, then global in reverse
+        const allInterceptors = [...this.errorInterceptors, ...globalInterceptors.reverse()];
+        let currentError = error;
+        for (let i = 0; i < allInterceptors.length; i++) {
+            try {
+                // If previous interceptor recovered with a response, stop processing
+                if (currentError instanceof ResponseWrapper) {
+                    return currentError;
+                }
+                const result = await allInterceptors[i](currentError);
+                currentError = result;
+            }
+            catch (interceptorError) {
+                // If an error interceptor throws, that becomes the new error
+                if (interceptorError instanceof RequestError) {
+                    currentError = interceptorError;
                 }
                 else {
-                    // Fallback for browsers without AbortSignal.timeout
-                    timeoutId = setTimeout(() => {
-                        if (!controller.signal.aborted) {
-                            abortedByTimeout = true;
-                            controller.abort();
-                        }
-                    }, this.requestOptions.timeout);
+                    const errorMessage = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
+                    // Always wrap in RequestError when we have context
+                    if (currentError instanceof RequestError) {
+                        currentError = new RequestError(`Error interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method);
+                    }
+                    else if (currentError instanceof ResponseWrapper && currentError.url && currentError.method) {
+                        // If it's a ResponseWrapper, we can still create a proper RequestError from its context
+                        currentError = new RequestError(`Error interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method);
+                    }
+                    else {
+                        // Last resort: if we have no context at all, use the original error's context
+                        // This shouldn't happen in practice, but handle it gracefully
+                        const errorObj = interceptorError instanceof Error ? interceptorError : new Error(String(interceptorError));
+                        currentError = RequestError.networkError(error.url, error.method, errorObj);
+                    }
                 }
             }
+        }
+        return currentError;
+    }
+    /**
+     * Helper to create an abort signal with timeout support
+     * Handles various AbortSignal API levels gracefully
+     */
+    createAbortSignal(timeoutMs, externalController) {
+        let timeoutId;
+        let timeoutController;
+        let isTimeout = false;
+        // No timeout - just use external controller
+        if (!timeoutMs) {
+            return {
+                signal: externalController === null || externalController === void 0 ? void 0 : externalController.signal,
+                cleanup: () => { },
+                wasTimeout: () => false,
+            };
+        }
+        // Check if AbortSignal.any() is available (modern browsers)
+        const hasAbortSignalAny = typeof AbortSignal.any === "function";
+        const hasAbortSignalTimeout = typeof AbortSignal.timeout === "function";
+        // Create timeout signal
+        const createTimeoutSignal = () => {
+            if (hasAbortSignalTimeout) {
+                const signal = AbortSignal.timeout(timeoutMs);
+                signal.addEventListener("abort", () => (isTimeout = true), { once: true });
+                return signal;
+            }
             else {
+                timeoutController = new AbortController();
                 timeoutId = setTimeout(() => {
-                    abortedByTimeout = true;
-                    controller.abort();
-                }, this.requestOptions.timeout);
+                    isTimeout = true;
+                    timeoutController.abort();
+                }, timeoutMs);
+                return timeoutController.signal;
             }
+        };
+        const timeoutSignal = createTimeoutSignal();
+        // Combine signals if we have both timeout and external controller
+        const finalSignal = externalController && hasAbortSignalAny
+            ? AbortSignal.any([externalController.signal, timeoutSignal])
+            : externalController
+                ? this.combineSignalsManually(externalController.signal, timeoutSignal)
+                : timeoutSignal;
+        return {
+            signal: finalSignal,
+            cleanup: () => {
+                if (timeoutId !== undefined)
+                    clearTimeout(timeoutId);
+            },
+            wasTimeout: () => isTimeout,
+        };
+    }
+    /**
+     * Manually combine two abort signals for older environments
+     * Returns the first signal and listens to the second
+     */
+    combineSignalsManually(signal1, signal2) {
+        // If either is already aborted, use that one
+        if (signal1.aborted)
+            return signal1;
+        if (signal2.aborted)
+            return signal2;
+        // Use a controller to create a combined signal
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        signal1.addEventListener("abort", abort, { once: true });
+        signal2.addEventListener("abort", abort, { once: true });
+        return controller.signal;
+    }
+    /**
+     * Convert fetchOptions to RequestConfig with proper typing
+     */
+    createRequestConfig(url, fetchOptions) {
+        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
+        const headers = this.getHeadersRecord();
+        const extendedOptions = fetchOptions;
+        return {
+            url,
+            method,
+            headers,
+            body: fetchOptions.body,
+            signal: fetchOptions.signal || undefined,
+            credentials: fetchOptions.credentials,
+            mode: fetchOptions.mode,
+            redirect: fetchOptions.redirect,
+            referrer: fetchOptions.referrer,
+            referrerPolicy: fetchOptions.referrerPolicy,
+            keepalive: fetchOptions.keepalive,
+            priority: extendedOptions.priority,
+        };
+    }
+    /**
+     * Apply interceptor results back to fetchOptions
+     */
+    applyRequestConfig(config, fetchOptions) {
+        fetchOptions.headers = config.headers;
+        if (config.body !== undefined) {
+            fetchOptions.body = config.body;
         }
+    }
+    async executeRequest(url, fetchOptions) {
+        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
+        // Setup abort signal with timeout
+        const abortSignal = this.createAbortSignal(this.requestOptions.timeout, this.abortController);
         try {
+            // Run request interceptors before making the request
+            const requestConfig = this.createRequestConfig(url, fetchOptions);
+            const interceptorResult = await this.runRequestInterceptors(requestConfig);
+            // If interceptor returned a Response, short-circuit and wrap it
+            if (interceptorResult instanceof Response) {
+                const wrappedResponse = new ResponseWrapper(interceptorResult, this.url, this.method);
+                return await this.runResponseInterceptors(wrappedResponse);
+            }
+            // Update fetchOptions with interceptor modifications
+            url = interceptorResult.url;
+            this.validateUrl(url);
+            this.applyRequestConfig(interceptorResult, fetchOptions);
+            // Set the combined abort signal
+            fetchOptions.signal = abortSignal.signal;
+            // Execute fetch
             let response;
             try {
                 response = await fetch(url, fetchOptions);
             }
             catch (error) {
-                // Check if this is an abort error that was specifically caused by our timeout
-                if (error instanceof DOMException && error.name === "AbortError" && abortedByTimeout) {
-                    throw RequestError.timeout(url, fetchOptions.method, this.requestOptions.timeout);
+                // Check if it's an abort error (DOMException in browsers, or AbortSignal abort)
+                if (error instanceof DOMException && error.name === "AbortError") {
+                    if (abortSignal.wasTimeout()) {
+                        throw RequestError.timeout(url, method, this.requestOptions.timeout);
+                    }
+                    throw RequestError.abortError(url, method);
+                }
+                // Check for Node.js/undici TimeoutError
+                const errorObj = error instanceof Error ? error : new Error(String(error));
+                const errorName = errorObj.name;
+                const errorMessage = errorObj.message.toLowerCase();
+                // Detect timeout errors from Node.js/undici (TimeoutError)
+                const isTimeoutError = errorName === "TimeoutError" || errorMessage.includes("timeout") || errorMessage.includes("aborted due to timeout") || abortSignal.wasTimeout();
+                if (isTimeoutError && this.requestOptions.timeout) {
+                    throw RequestError.timeout(url, method, this.requestOptions.timeout);
                 }
-                // Otherwise it's either a user-triggered abort or another network error
-                throw RequestError.networkError(url, fetchOptions.method, error);
+                throw RequestError.networkError(url, method, errorObj);
             }
             if (!response.ok) {
-                throw RequestError.fromResponse(response, url, fetchOptions.method);
+                throw RequestError.fromResponse(response, url, method);
             }
-            // Return a wrapped response instead of parsing it
-            return new ResponseWrapper(response);
+            const wrappedResponse = new ResponseWrapper(response, url, method);
+            return await this.runResponseInterceptors(wrappedResponse);
         }
-        finally {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-        }
-    }
-    /**
-     * Executes a request using cache when possible
-     * @param url The formatted URL to send the request to
-     * @param fetchOptions The fetch options to use
-     * @param cacheKey The cache key for this request
-     */
-    async executeWithCache(url, fetchOptions, cacheKey) {
-        // Try to get from cache first
-        if (this.cacheManager) {
-            const cachedEntry = await this.cacheManager.get(cacheKey);
-            if (cachedEntry) {
-                // Create a synthetic Response object from cached data
-                const cachedResponse = new Response(JSON.stringify(cachedEntry.value), {
-                    status: 200,
-                    headers: new Headers(cachedEntry.headers || {}),
-                });
-                return new ResponseWrapper(cachedResponse);
+        catch (error) {
+            // Convert to RequestError if needed
+            let requestError;
+            if (error instanceof RequestError) {
+                requestError = error;
             }
-        }
-        // Not in cache, make the actual request
-        const response = await (!this.requestOptions.retries ? this.executeRequest(url, fetchOptions) : this.executeWithRetries(url, fetchOptions));
-        // Cache the successful response if caching is enabled
-        // Only cache successful responses
-        if (response.ok && this.cacheManager) {
-            // Clone the response so we don't consume it
-            try {
-                const responseData = await response.getJson();
-                // Extract headers to store in cache
-                const headers = {};
-                response.headers.forEach((value, key) => {
-                    headers[key] = value;
-                });
-                // Store in cache
-                await this.cacheManager.set(cacheKey, responseData, headers);
+            else {
+                const errorObj = error instanceof Error ? error : new Error(String(error));
+                requestError = RequestError.networkError(url, method, errorObj);
             }
-            catch (error) {
-                // Failed to cache, but we can still return the response
-                console.warn("Failed to cache response:", error);
+            // Run error interceptors
+            const interceptorResult = await this.runErrorInterceptors(requestError);
+            // If error interceptor returned a ResponseWrapper, recover from error
+            if (interceptorResult instanceof ResponseWrapper) {
+                return interceptorResult;
             }
+            throw interceptorResult;
+        }
+        finally {
+            abortSignal.cleanup();
         }
-        return response;
     }
-}/**
+}
+
+/**
  * Base class for requests that can have a body (POST, PUT, PATCH)
  */
 class BodyRequest extends BaseRequest {
+    constructor(url) {
+        super(url);
+    }
     /**
      * Sets the body of the request
      * @param body - The request body
@@ -1611,7 +1784,7 @@ class BodyRequest extends BaseRequest {
                 JSON.stringify(body);
             }
             catch (error) {
-                throw new Error(`Failed to stringify request body: ${String(error)}`);
+                throw new RequestError(`Stringify failed: ${String(error)}`, this.url, this.method);
             }
         }
         else {
@@ -1619,18 +1792,68 @@ class BodyRequest extends BaseRequest {
         }
         return this;
     }
-    setContentTypeIfNeeded(contentType) {
-        // Only set if not already set
+    /**
+     * Sets a GraphQL query or mutation as the request body
+     * Automatically formats the body as JSON and sets Content-Type to application/json
+     *
+     * @param query - The GraphQL query or mutation string
+     * @param variables - Optional variables object to pass with the query
+     * @returns The request instance for chaining
+     *
+     * @example
+     * const request = new PostRequest('/graphql')
+     *   .withGraphQL('query { user(id: $id) { name email } }', { id: '123' });
+     *
+     * @example
+     * const request = new PostRequest('/graphql')
+     *   .withGraphQL('mutation { createUser(name: $name) { id } }', { name: 'John' });
+     */
+    withGraphQL(query, variables) {
+        if (typeof query !== "string" || query.trim().length === 0) {
+            throw new RequestError("Invalid GraphQL query", this.url, this.method);
+        }
+        const graphQLBody = {
+            query: query.trim(),
+        };
+        if (variables !== undefined) {
+            if (typeof variables !== "object" || variables === null || Array.isArray(variables)) {
+                throw new RequestError("Invalid GraphQL variables", this.url, this.method);
+            }
+            graphQLBody.variables = variables;
+        }
+        // Validate JSON is stringifiable early
+        try {
+            JSON.stringify(graphQLBody);
+        }
+        catch (error) {
+            throw new RequestError(`Stringify failed: ${String(error)}`, this.url, this.method);
+        }
+        this.body = graphQLBody;
+        this.bodyType = BodyType.JSON;
+        this.setContentTypeIfNeeded("application/json");
+        return this;
+    }
+    /**
+     * Check if Content-Type header is already set (case-insensitive)
+     */
+    hasContentType() {
         const headers = this.requestOptions.headers;
-        if (!Object.keys(headers).some(header => header.toLowerCase() === "content-type")) {
+        if (typeof headers === "object" && headers !== null) {
+            const headersObj = headers;
+            return Object.keys(headersObj).some(header => header.toLowerCase() === "content-type");
+        }
+        return false;
+    }
+    setContentTypeIfNeeded(contentType) {
+        if (!this.hasContentType()) {
             this.withContentType(contentType);
         }
     }
     /**
-     * Send the request to the specified URL
+     * Execute the request and return the ResponseWrapper
      * Overrides the base implementation to add body handling
      */
-    sendTo(url) {
+    async getResponse() {
         if (this.body !== undefined) {
             // Remove previous body if it exists
             if (this.requestOptions.body)
@@ -1643,20 +1866,22 @@ class BodyRequest extends BaseRequest {
                 this.requestOptions.body = this.body;
             }
         }
-        return super.sendTo(url);
+        return super.getResponse();
     }
-}/**
+}
+
+/**
  * HTTP GET request implementation
  * Used for retrieving data from an API endpoint.
  *
  * @example
- * const request = new GetRequest()
- *   .withQueryParams({ id: '123' })
- *   .sendTo('/api/users');
+ * const request = new GetRequest('/api/users')
+ *   .withQueryParams({ id: '123' });
+ * const data = await request.getData();
  */
 class GetRequest extends BaseRequest {
-    constructor() {
-        super(...arguments);
+    constructor(url) {
+        super(url);
         this.method = HttpMethod.GET;
     }
 }
@@ -1665,12 +1890,12 @@ class GetRequest extends BaseRequest {
  * Similar to GET but returns only headers without a response body.
  *
  * @example
- * const request = new HeadRequest()
- *   .sendTo('/api/users/123');
+ * const request = new HeadRequest('/api/users/123');
+ * const response = await request.getResponse();
  */
 class HeadRequest extends BaseRequest {
-    constructor() {
-        super(...arguments);
+    constructor(url) {
+        super(url);
         this.method = HttpMethod.HEAD;
     }
 }
@@ -1679,12 +1904,12 @@ class HeadRequest extends BaseRequest {
  * Used to describe the communication options for the target resource.
  *
  * @example
- * const request = new OptionsRequest()
- *   .sendTo('/api/users');
+ * const request = new OptionsRequest('/api/users');
+ * const response = await request.getResponse();
  */
 class OptionsRequest extends BaseRequest {
-    constructor() {
-        super(...arguments);
+    constructor(url) {
+        super(url);
         this.method = HttpMethod.OPTIONS;
     }
 }
@@ -1693,12 +1918,12 @@ class OptionsRequest extends BaseRequest {
  * Used to delete a resource on the server.
  *
  * @example
- * const request = new DeleteRequest()
- *   .sendTo('/api/users/123');
+ * const request = new DeleteRequest('/api/users/123');
+ * await request.getData();
  */
 class DeleteRequest extends BaseRequest {
-    constructor() {
-        super(...arguments);
+    constructor(url) {
+        super(url);
         this.method = HttpMethod.DELETE;
     }
 }
@@ -1707,13 +1932,13 @@ class DeleteRequest extends BaseRequest {
  * Used to create a new resource or submit data for processing.
  *
  * @example
- * const request = new PostRequest()
- *   .withJson({ name: 'John', email: 'john@example.com' })
- *   .sendTo('/api/users');
+ * const request = new PostRequest('/api/users')
+ *   .withJson({ name: 'John', email: 'john@example.com' });
+ * const data = await request.getData();
  */
 class PostRequest extends BodyRequest {
-    constructor() {
-        super(...arguments);
+    constructor(url) {
+        super(url);
         this.method = HttpMethod.POST;
     }
 }
@@ -1722,13 +1947,13 @@ class PostRequest extends BodyRequest {
  * Used to replace or update an existing resource.
  *
  * @example
- * const request = new PutRequest()
- *   .withJson({ id: '123', name: 'John', email: 'john@example.com' })
- *   .sendTo('/api/users/123');
+ * const request = new PutRequest('/api/users/123')
+ *   .withJson({ id: '123', name: 'John', email: 'john@example.com' });
+ * const data = await request.getData();
  */
 class PutRequest extends BodyRequest {
-    constructor() {
-        super(...arguments);
+    constructor(url) {
+        super(url);
         this.method = HttpMethod.PUT;
     }
 }
@@ -1737,117 +1962,123 @@ class PutRequest extends BodyRequest {
  * Used to apply partial modifications to a resource.
  *
  * @example
- * const request = new PatchRequest()
- *   .withJson({ email: 'new.email@example.com' })
- *   .sendTo('/api/users/123');
+ * const request = new PatchRequest('/api/users/123')
+ *   .withJson({ email: 'new.email@example.com' });
+ * const data = await request.getData();
  */
 class PatchRequest extends BodyRequest {
-    constructor() {
-        super(...arguments);
+    constructor(url) {
+        super(url);
         this.method = HttpMethod.PATCH;
     }
-}/**
+}
+
+/**
  * Create a GET request
  * Used for retrieving resources from the server.
  *
+ * @param url - The URL to send the request to
  * @returns A new GET request instance
  *
  * @example
- * const users = await get()
- *   .withQueryParams({ limit: 10 })
- *   .sendTo('/api/users')
- *   .getJson();
+ * const request = get('/api/users')
+ *   .withQueryParams({ limit: 10 });
+ * const users = await request.getData();
  */
-function get() {
-    return new GetRequest();
+function get(url) {
+    return new GetRequest(url);
 }
 /**
  * Create a POST request
  * Used for creating new resources or submitting data.
  *
+ * @param url - The URL to send the request to
  * @returns A new POST request instance
  *
  * @example
- * const newUser = await post()
- *   .withJson({ name: 'John', email: 'john@example.com' })
- *   .sendTo('/api/users')
- *   .getJson();
+ * const request = post('/api/users')
+ *   .withJson({ name: 'John', email: 'john@example.com' });
+ * const newUser = await request.getData();
  */
-function post() {
-    return new PostRequest();
+function post(url) {
+    return new PostRequest(url);
 }
 /**
  * Create a PUT request
  * Used for replacing or updating an existing resource.
  *
+ * @param url - The URL to send the request to
  * @returns A new PUT request instance
  *
  * @example
- * const updatedUser = await put()
- *   .withJson({ name: 'John Updated', email: 'john@example.com' })
- *   .sendTo('/api/users/123')
- *   .getJson();
+ * const request = put('/api/users/123')
+ *   .withJson({ name: 'John Updated', email: 'john@example.com' });
+ * const updatedUser = await request.getData();
  */
-function put() {
-    return new PutRequest();
+function put(url) {
+    return new PutRequest(url);
 }
 /**
  * Create a DELETE request
  * Used for removing resources from the server.
  *
+ * @param url - The URL to send the request to
  * @returns A new DELETE request instance
  *
  * @example
- * await del()
- *   .sendTo('/api/users/123')
- *   .getJson();
+ * const request = del('/api/users/123');
+ * await request.getData();
  */
-function del() {
-    return new DeleteRequest();
+function del(url) {
+    return new DeleteRequest(url);
 }
 /**
  * Create a PATCH request
  * Used for applying partial modifications to a resource.
  *
+ * @param url - The URL to send the request to
  * @returns A new PATCH request instance
  *
  * @example
- * const patchedUser = await patch()
- *   .withJson({ status: 'active' })
- *   .sendTo('/api/users/123')
- *   .getJson();
+ * const request = patch('/api/users/123')
+ *   .withJson({ status: 'active' });
+ * const patchedUser = await request.getData();
  */
-function patch() {
-    return new PatchRequest();
+function patch(url) {
+    return new PatchRequest(url);
 }
 /**
  * Create a HEAD request
  * Similar to GET but returns only headers without a body.
  *
+ * @param url - The URL to send the request to
  * @returns A new HEAD request instance
  *
  * @example
- * const response = await head()
- *   .sendTo('/api/users/123');
+ * const request = head('/api/users/123');
+ * const response = await request.getResponse();
  * console.log(response.headers.get('Last-Modified'));
  */
-function head() {
-    return new HeadRequest();
+function head(url) {
+    return new HeadRequest(url);
 }
 /**
  * Create an OPTIONS request
  * Used to describe the communication options for a resource.
  *
+ * @param url - The URL to send the request to
  * @returns A new OPTIONS request instance
  *
  * @example
- * const response = await options()
- *   .sendTo('/api/users');
+ * const request = options('/api/users');
+ * const response = await request.getResponse();
  * console.log(response.headers.get('Allow'));
  */
-function options() {
-    return new OptionsRequest();
-}/**
+function options(url) {
+    return new OptionsRequest(url);
+}
+
+/**
  * Main API object for creating HTTP requests
  * Provides factory methods for all HTTP methods and access to global configuration.
  */
@@ -1860,4 +2091,7 @@ const create = {
     head,
     options,
     config: Config.getInstance(),
-};export{CacheManager,CacheMode,CookieUtils,CredentialsPolicy,DeleteRequest,GetRequest,HeadRequest,HttpMethod,OptionsRequest,PatchRequest,PostRequest,PutRequest,RedirectMode,ReferrerPolicy,RequestError,RequestMode,RequestPriority,ResponseWrapper,SameSitePolicy,createLocalStorageStorage,createMemoryStorage,createSessionStorageStorage,create as default};//# sourceMappingURL=index.esm.js.map
+};
+
+export { CookieUtils, CredentialsPolicy, DeleteRequest, GetRequest, HeadRequest, HttpMethod, OptionsRequest, PatchRequest, PostRequest, PutRequest, RedirectMode, ReferrerPolicy, RequestError, RequestMode, RequestPriority, ResponseWrapper, SameSitePolicy, create as default };
+//# sourceMappingURL=index.esm.js.map