create-request 0.0.1-beta.10

package/dist/library/index.js

@@ -0,0 +1,1930 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.createRequest = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Enum for HTTP methods
+     */
+    exports.HttpMethod = void 0;
+    (function (HttpMethod) {
+        HttpMethod["GET"] = "GET";
+        HttpMethod["PUT"] = "PUT";
+        HttpMethod["POST"] = "POST";
+        HttpMethod["HEAD"] = "HEAD";
+        HttpMethod["PATCH"] = "PATCH";
+        HttpMethod["DELETE"] = "DELETE";
+        HttpMethod["OPTIONS"] = "OPTIONS";
+    })(exports.HttpMethod || (exports.HttpMethod = {}));
+    /**
+     * Enum for request priorities
+     */
+    exports.RequestPriority = void 0;
+    (function (RequestPriority) {
+        RequestPriority["LOW"] = "low";
+        RequestPriority["HIGH"] = "high";
+        RequestPriority["AUTO"] = "auto";
+    })(exports.RequestPriority || (exports.RequestPriority = {}));
+    /**
+     * Enum for credentials policies
+     */
+    exports.CredentialsPolicy = void 0;
+    (function (CredentialsPolicy) {
+        CredentialsPolicy["OMIT"] = "omit";
+        CredentialsPolicy["INCLUDE"] = "include";
+        CredentialsPolicy["SAME_ORIGIN"] = "same-origin";
+    })(exports.CredentialsPolicy || (exports.CredentialsPolicy = {}));
+    /**
+     * Enum for request modes
+     */
+    exports.RequestMode = void 0;
+    (function (RequestMode) {
+        RequestMode["CORS"] = "cors";
+        RequestMode["NO_CORS"] = "no-cors";
+        RequestMode["SAME_ORIGIN"] = "same-origin";
+        RequestMode["NAVIGATE"] = "navigate";
+    })(exports.RequestMode || (exports.RequestMode = {}));
+    /**
+     * Enum for redirect modes
+     */
+    exports.RedirectMode = void 0;
+    (function (RedirectMode) {
+        RedirectMode["ERROR"] = "error";
+        RedirectMode["FOLLOW"] = "follow";
+        RedirectMode["MANUAL"] = "manual";
+    })(exports.RedirectMode || (exports.RedirectMode = {}));
+    /**
+     * Enum for cache modes
+     */
+    exports.CacheMode = void 0;
+    (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";
+    })(exports.CacheMode || (exports.CacheMode = {}));
+    /**
+     * Enum for cookie SameSite policies
+     */
+    exports.SameSitePolicy = void 0;
+    (function (SameSitePolicy) {
+        SameSitePolicy["LAX"] = "Lax";
+        SameSitePolicy["NONE"] = "None";
+        SameSitePolicy["STRICT"] = "Strict";
+    })(exports.SameSitePolicy || (exports.SameSitePolicy = {}));
+    /**
+     * Enum for body types
+     */
+    var BodyType;
+    (function (BodyType) {
+        BodyType["JSON"] = "json";
+        BodyType["STRING"] = "string";
+        BodyType["BINARY"] = "binary";
+    })(BodyType || (BodyType = {}));
+    /**
+     * Referrer policies for fetch requests
+     */
+    exports.ReferrerPolicy = void 0;
+    (function (ReferrerPolicy) {
+        ReferrerPolicy["ORIGIN"] = "origin";
+        ReferrerPolicy["UNSAFE_URL"] = "unsafe-url";
+        ReferrerPolicy["SAME_ORIGIN"] = "same-origin";
+        ReferrerPolicy["NO_REFERRER"] = "no-referrer";
+        ReferrerPolicy["STRICT_ORIGIN"] = "strict-origin";
+        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";
+    })(exports.ReferrerPolicy || (exports.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.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;
+        }
+    }
+
+    /**
+     * Wrapper for HTTP responses with methods to transform the response data
+     * Provides caching and conversion between different response formats.
+     */
+    class ResponseWrapper {
+        constructor(response) {
+            this.bodyUsed = false;
+            this.response = response;
+        }
+        // Wrapper properties
+        get status() {
+            return this.response.status;
+        }
+        get statusText() {
+            return this.response.statusText;
+        }
+        get headers() {
+            return this.response.headers;
+        }
+        get ok() {
+            return this.response.ok;
+        }
+        get raw() {
+            return this.response;
+        }
+        /**
+         * Parse the response body as JSON
+         * Caches the result for subsequent calls.
+         *
+         * @returns The parsed JSON data
+         * @throws Error if the response has already been consumed in a different format
+         *
+         * @example
+         * const data = await response.getJson();
+         * console.log(data.items);
+         */
+        async getJson() {
+            if (this.jsonCache !== undefined) {
+                return this.jsonCache;
+            }
+            if (this.bodyUsed) {
+                // 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;
+                    }
+                    catch (e) {
+                        throw new Error("Cannot parse cached text as JSON");
+                    }
+                }
+                throw new Error("Response body has already been consumed in a different format");
+            }
+            this.bodyUsed = true;
+            this.jsonCache = (await this.response.json());
+            return this.jsonCache;
+        }
+        /**
+         * Get the response body as text
+         * Caches the result for subsequent calls. Attempts to convert from JSON or Blob
+         * if the body has already been consumed in those formats.
+         *
+         * @returns The response text
+         * @throws Error if the response has already been consumed in an incompatible format
+         *
+         * @example
+         * const text = await response.getText();
+         */
+        async getText() {
+            if (this.textCache !== undefined) {
+                return this.textCache;
+            }
+            if (this.bodyUsed) {
+                // If we already have JSON, convert it to text
+                if (this.jsonCache !== undefined) {
+                    this.textCache = JSON.stringify(this.jsonCache);
+                    return this.textCache;
+                }
+                // If we have blob, convert to text
+                if (this.blobCache !== undefined) {
+                    this.textCache = await this.blobCache.text();
+                    return this.textCache;
+                }
+                throw new Error("Response body has already been consumed in a format that cannot be converted to text");
+            }
+            this.bodyUsed = true;
+            this.textCache = await this.response.text();
+            return this.textCache;
+        }
+        /**
+         * Get the response body as a Blob
+         * Caches the result for subsequent calls. Attempts to convert from text
+         * if the body has already been consumed as text.
+         *
+         * @returns The response as a Blob
+         * @throws Error if the response has already been consumed in an incompatible format
+         *
+         * @example
+         * const blob = await response.getBlob();
+         * const url = URL.createObjectURL(blob);
+         */
+        async getBlob() {
+            if (this.blobCache !== undefined) {
+                return this.blobCache;
+            }
+            if (this.bodyUsed) {
+                // If we have text, convert to Blob
+                if (this.textCache !== undefined) {
+                    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");
+            }
+            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;
+            }
+            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;
+                }
+                throw new Error("Response body has already been consumed in a format that cannot be converted to ArrayBuffer");
+            }
+            this.bodyUsed = true;
+            this.arrayBufferCache = await this.response.arrayBuffer();
+            return this.arrayBufferCache;
+        }
+        /**
+         * Get the raw response body as a ReadableStream
+         * This method consumes the body and should only be called once.
+         *
+         * @returns The response body as a ReadableStream or null
+         * @throws Error if the response body has already been consumed
+         *
+         * @example
+         * const stream = response.getBody();
+         * if (stream) {
+         *   const reader = stream.getReader();
+         *   // Process the stream
+         * }
+         */
+        getBody() {
+            if (this.bodyUsed) {
+                throw new Error("Response body has already been consumed");
+            }
+            this.bodyUsed = true;
+            return this.response.body;
+        }
+    }
+
+    /**
+     * 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
+     *
+     * @example
+     * parseSize("10MB") // returns 10485760
+     * parseSize(1024) // returns 1024
+     */
+    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;
+        }
+    }
+    /**
+     * 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();
+    }
+
+    /**
+     * 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.
+         *
+         * @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
+         *
+         * @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.
+         *
+         * @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");
+         */
+        async get(key) {
+            const value = await Promise.resolve(this.storage.get(key));
+            if (!value)
+                return null;
+            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;
+            }
+        }
+        /**
+         * 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;
+                }
+                // 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;
+                }
+                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;
+                }
+            }
+            // 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());
+        }
+    }
+
+    /**
+     * Global configuration for create-request
+     */
+    class Config {
+        constructor() {
+            // CSRF configuration
+            this.csrfHeaderName = "X-CSRF-Token";
+            this.xsrfCookieName = "XSRF-TOKEN";
+            this.xsrfHeaderName = "X-XSRF-TOKEN";
+            this.csrfToken = null;
+            this.enableAutoXsrf = true;
+            this.enableAntiCsrf = true; // X-Requested-With header
+        }
+        /**
+         * Get the singleton instance of the Config class
+         *
+         * @returns The global configuration instance
+         *
+         * @example
+         * const config = Config.getInstance();
+         * config.setCsrfToken('token123');
+         */
+        static getInstance() {
+            if (!Config.instance) {
+                Config.instance = new Config();
+            }
+            return Config.instance;
+        }
+        /**
+         * Set a global CSRF token to be used for all requests
+         *
+         * @param token - The CSRF token value
+         * @returns The config instance for chaining
+         *
+         * @example
+         * Config.getInstance().setCsrfToken('myToken123');
+         */
+        setCsrfToken(token) {
+            this.csrfToken = token;
+            return this;
+        }
+        /**
+         * Get the global CSRF token that will be automatically applied to requests
+         *
+         * @returns The current CSRF token or null if not set
+         */
+        getCsrfToken() {
+            return this.csrfToken;
+        }
+        /**
+         * Set the CSRF header name used when sending the token
+         *
+         * @param name - The header name to use
+         * @returns The config instance for chaining
+         *
+         * @example
+         * Config.getInstance().setCsrfHeaderName('X-My-CSRF-Token');
+         */
+        setCsrfHeaderName(name) {
+            this.csrfHeaderName = name;
+            return this;
+        }
+        /**
+         * Get the configured CSRF header name
+         *
+         * @returns The current CSRF header name
+         */
+        getCsrfHeaderName() {
+            return this.csrfHeaderName;
+        }
+        /**
+         * Set the XSRF cookie name to look for when extracting tokens from cookies
+         *
+         * @param name - The cookie name to look for
+         * @returns The config instance for chaining
+         *
+         * @example
+         * Config.getInstance().setXsrfCookieName('MY-XSRF-COOKIE');
+         */
+        setXsrfCookieName(name) {
+            this.xsrfCookieName = name;
+            return this;
+        }
+        /**
+         * Get the configured XSRF cookie name
+         *
+         * @returns The current XSRF cookie name
+         */
+        getXsrfCookieName() {
+            return this.xsrfCookieName;
+        }
+        /**
+         * Set the XSRF header name for sending tokens extracted from cookies
+         *
+         * @param name - The header name to use
+         * @returns The config instance for chaining
+         */
+        setXsrfHeaderName(name) {
+            this.xsrfHeaderName = name;
+            return this;
+        }
+        /**
+         * Get the configured XSRF header name
+         *
+         * @returns The current XSRF header name
+         */
+        getXsrfHeaderName() {
+            return this.xsrfHeaderName;
+        }
+        /**
+         * Enable or disable automatic extraction of XSRF tokens from cookies
+         * When enabled, the library will look for XSRF tokens in cookies and
+         * automatically add them to request headers.
+         *
+         * @param enable - Whether to enable this feature
+         * @returns The config instance for chaining
+         *
+         * @example
+         * Config.getInstance().setEnableAutoXsrf(false); // Disable XSRF extraction
+         */
+        setEnableAutoXsrf(enable) {
+            this.enableAutoXsrf = enable;
+            return this;
+        }
+        /**
+         * Check if automatic XSRF token extraction is enabled
+         *
+         * @returns True if automatic XSRF is enabled
+         */
+        isAutoXsrfEnabled() {
+            return this.enableAutoXsrf;
+        }
+        /**
+         * Enable or disable automatic addition of anti-CSRF headers
+         * When enabled, X-Requested-With: XMLHttpRequest will be added to all requests.
+         *
+         * @param enable - Whether to enable this feature
+         * @returns The config instance for chaining
+         */
+        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;
+        }
+        /**
+         * Reset all configuration options to their default values
+         *
+         * @returns The config instance for chaining
+         *
+         * @example
+         * Config.getInstance().reset();
+         */
+        reset() {
+            this.csrfToken = null;
+            this.csrfHeaderName = "X-CSRF-Token";
+            this.enableAntiCsrf = true;
+            this.xsrfCookieName = "XSRF-TOKEN";
+            this.xsrfHeaderName = "X-XSRF-TOKEN";
+            this.enableAutoXsrf = true;
+            return this;
+        }
+    }
+
+    class CookieUtils {
+        /**
+         * Formats cookies for a request
+         * @param cookies Object containing cookie name-value pairs or cookie options
+         * @returns Formatted cookie string for the Cookie header
+         */
+        static formatRequestCookies(cookies) {
+            const cookiePairs = [];
+            Object.entries(cookies).forEach(([name, valueOrOptions]) => {
+                let value;
+                if (typeof valueOrOptions === "string") {
+                    value = valueOrOptions;
+                }
+                else {
+                    // Extract value from options object without validation
+                    value = valueOrOptions.value;
+                }
+                // Add the cookie to the request
+                cookiePairs.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
+            });
+            return cookiePairs.join("; ");
+        }
+    }
+
+    /**
+     * Utility class for CSRF token management
+     */
+    class CsrfUtils {
+        /**
+         * Extracts CSRF token from a meta tag in the document head
+         * @param metaName The name attribute of the meta tag (default: "csrf-token")
+         * @returns The CSRF token or null if not found
+         */
+        static getTokenFromMeta(metaName = "csrf-token") {
+            if (typeof document === "undefined") {
+                return null;
+            }
+            const meta = document.querySelector(`meta[name="${metaName}"]`);
+            return (meta === null || meta === void 0 ? void 0 : meta.getAttribute("content")) || null;
+        }
+        /**
+         * Extracts CSRF token from a cookie
+         * @param cookieName The name of the cookie containing the CSRF token
+         * @returns The CSRF token or null if not found
+         */
+        static getTokenFromCookie(cookieName = "csrf-token") {
+            if (typeof document === "undefined") {
+                return null;
+            }
+            const cookies = document.cookie.split(";");
+            for (const cookie of cookies) {
+                const [name, value] = cookie.trim().split("=");
+                if (name === cookieName) {
+                    return decodeURIComponent(value);
+                }
+            }
+            return null;
+        }
+        /**
+         * Validates if the provided string is a potential CSRF token
+         * Checks if the token meets security requirements
+         * @param token The token to validate
+         * @returns Whether the token is valid
+         */
+        static isValidToken(token) {
+            // Basic checks for null/undefined and type
+            if (typeof token !== "string") {
+                return false;
+            }
+            if (token.length < 8)
+                return false;
+            // If token is longer than 10 chars, perform additional security checks
+            if (token.length > 10) {
+                // Check for valid character set (alphanumeric & common token symbols)
+                const validTokenRegex = /^[A-Za-z0-9\-_=+/.]+$/;
+                if (!validTokenRegex.test(token)) {
+                    return false;
+                }
+                // For longer tokens, check for sufficient entropy (at least 2 character types)
+                const hasUpperCase = /[A-Z]/.test(token);
+                const hasLowerCase = /[a-z]/.test(token);
+                const hasNumbers = /[0-9]/.test(token);
+                const hasSpecials = /[-_=+/.]/.test(token);
+                const characterTypesCount = [hasUpperCase, hasLowerCase, hasNumbers, hasSpecials].filter(Boolean).length;
+                return characterTypesCount >= 2;
+            }
+            // For shorter tokens (8-10 chars), just return true if we reached here
+            return true;
+        }
+    }
+
+    /**
+     * Base class with common functionality for all request types
+     * Provides the core request building and execution capabilities.
+     */
+    class BaseRequest {
+        constructor() {
+            this.requestOptions = {
+                headers: {},
+            };
+            this.queryParams = new URLSearchParams();
+            this.autoApplyCsrfProtection = true;
+            this.cacheEnabled = false;
+        }
+        /**
+         * Add multiple HTTP headers to the request
+         *
+         * @param headers - Key-value pairs of header names and values
+         * @returns The request instance for chaining
+         *
+         * @example
+         * request.withHeaders({
+         *   'Accept': 'application/json',
+         *   'X-Custom-Header': 'value'
+         * });
+         */
+        withHeaders(headers) {
+            this.requestOptions.headers = {
+                ...this.requestOptions.headers,
+                ...headers,
+            };
+            return this;
+        }
+        /**
+         * Add a single HTTP header to the request
+         *
+         * @param key - The header name
+         * @param value - The header value
+         * @returns The request instance for chaining
+         *
+         * @example
+         * request.withHeader('Accept', 'application/json');
+         */
+        withHeader(key, value) {
+            return this.withHeaders({ [key]: value });
+        }
+        /**
+         * Set a timeout for the request
+         * If the request takes longer than the specified timeout, it will be aborted.
+         *
+         * @param timeout - The timeout in milliseconds
+         * @returns The request instance for chaining
+         * @throws Error if timeout is not a positive number
+         *
+         * @example
+         * request.withTimeout(5000); // 5 seconds timeout
+         */
+        withTimeout(timeout) {
+            if (!Number.isFinite(timeout) || timeout <= 0)
+                throw new Error("Timeout must be a positive number");
+            this.requestOptions.timeout = timeout;
+            return this;
+        }
+        /**
+         * Configure automatic retry behavior for failed requests
+         *
+         * @param retries - Number of retry attempts before failing
+         * @returns The request instance for chaining
+         * @throws Error if retries is not a non-negative integer
+         *
+         * @example
+         * request.withRetries(3); // Retry up to 3 times
+         */
+        withRetries(retries) {
+            if (!Number.isInteger(retries) || retries < 0)
+                throw new Error("Retry count must be a non-negative integer");
+            this.requestOptions.retries = retries;
+            return this;
+        }
+        /**
+         * Set a callback to be invoked before each retry attempt
+         * Useful for implementing backoff strategies or logging retry attempts.
+         *
+         * @param callback - Function to call before retrying
+         * @returns The request instance for chaining
+         *
+         * @example
+         * request.onRetry(({ attempt, error }) => {
+         *   console.log(`Retry attempt ${attempt} after error: ${error.message}`);
+         *   return new Promise(resolve => setTimeout(resolve, attempt * 1000));
+         * });
+         */
+        onRetry(callback) {
+            this.requestOptions.onRetry = callback;
+            return this;
+        }
+        /**
+         * Sets the credentials policy for the request
+         * @param credentialsPolicy - Can be 'omit', 'same-origin', or 'include'
+         * @returns The instance for chaining
+         */
+        withCredentials(credentialsPolicy = exports.CredentialsPolicy.SAME_ORIGIN) {
+            this.requestOptions.credentials = credentialsPolicy;
+            return this;
+        }
+        /**
+         * Allows providing an external AbortController to cancel the request
+         * @param controller - The AbortController to use for this request
+         * @returns The instance for chaining
+         */
+        withAbortController(controller) {
+            this.abortController = controller;
+            return this;
+        }
+        /**
+         * Sets the referrer for the request
+         * @param referrer - The referrer URL or policy
+         * @returns The instance for chaining
+         */
+        withReferrer(referrer) {
+            this.requestOptions.referrer = referrer;
+            return this;
+        }
+        /**
+         * Sets the referrer policy for the request
+         * @param policy - The referrer policy to use
+         * @returns The instance for chaining
+         */
+        withReferrerPolicy(policy) {
+            this.requestOptions.referrerPolicy = policy;
+            return this;
+        }
+        /**
+         * Sets the redirect policy for the request
+         * @param redirect - Can be 'follow', 'error', or 'manual'
+         * @returns The instance for chaining
+         */
+        withRedirect(redirect) {
+            this.requestOptions.redirect = redirect;
+            return this;
+        }
+        /**
+         * Sets the keepalive flag for the request
+         * @param keepalive - Whether to allow the request to outlive the page
+         * @returns The instance for chaining
+         */
+        withKeepAlive(keepalive) {
+            this.requestOptions.keepalive = keepalive;
+            return this;
+        }
+        /**
+         * Sets the priority of the request
+         * @param priority - Can be 'high', 'low', or 'auto'
+         * @returns The instance for chaining
+         */
+        withPriority(priority) {
+            this.requestOptions.priority = priority;
+            return this;
+        }
+        /**
+         * Adds query parameters to the request URL
+         * @param params - An object containing the query parameters
+         * @returns The instance for chaining
+         */
+        withQueryParams(params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value === null || value === undefined) {
+                    return;
+                }
+                if (Array.isArray(value)) {
+                    // Handle array values - add multiple entries with the same key
+                    value.forEach(v => this.queryParams.append(key, String(v)));
+                }
+                else {
+                    this.queryParams.append(key, String(value));
+                }
+            });
+            return this;
+        }
+        /**
+         * Adds a single query parameter
+         * @param key - The parameter name
+         * @param value - The parameter value, can be a single value or array of values
+         * @returns The instance for chaining
+         */
+        withQueryParam(key, value) {
+            if (value === null || value === undefined)
+                return this;
+            if (Array.isArray(value))
+                value.forEach(v => this.queryParams.append(key, String(v)));
+            else
+                this.queryParams.append(key, String(value));
+            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
+         */
+        withMode(mode) {
+            this.requestOptions.mode = mode;
+            return this;
+        }
+        /**
+         * Shorthand for setting the Content-Type header
+         * @param contentType - The content type
+         * @returns The instance for chaining
+         */
+        withContentType(contentType) {
+            return this.withHeaders({
+                "Content-Type": contentType,
+            });
+        }
+        /**
+         * Shorthand for setting the Authorization header
+         * @param authValue - The authorization value
+         * @returns The instance for chaining
+         */
+        withAuthorization(authValue) {
+            return this.withHeaders({
+                Authorization: authValue,
+            });
+        }
+        /**
+         * Shorthand for setting up Basic authentication
+         * @param username - The username
+         * @param password - The password
+         * @returns The instance for chaining
+         */
+        withBasicAuth(username, password) {
+            const credentials = this.encodeBase64(`${username}:${password}`);
+            return this.withAuthorization(`Basic ${credentials}`);
+        }
+        /**
+         * Cross-environment base64 encoding
+         * Works in both browser and Node.js environments
+         */
+        encodeBase64(str) {
+            // Modern approach using TextEncoder (available in both modern browsers and Node.js)
+            if (typeof TextEncoder !== "undefined" && typeof btoa === "function") {
+                const encoder = new TextEncoder();
+                const bytes = encoder.encode(str);
+                return btoa(String.fromCharCode.apply(null, [...new Uint8Array(bytes)]));
+            }
+            // Browser environment
+            if (typeof btoa === "function")
+                return btoa(str);
+            // Node.js environment
+            if (typeof Buffer !== "undefined")
+                return Buffer.from(str).toString("base64");
+            // Fallback (should never happen in modern environments)
+            throw new Error("Base64 encoding is not supported in this environment");
+        }
+        /**
+         * Sets the bearer token for authentication
+         * @param token - The bearer token
+         * @returns The instance for chaining
+         */
+        withBearerToken(token) {
+            return this.withAuthorization(`Bearer ${token}`);
+        }
+        /**
+         * 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) {
+            return Object.keys(headers).some(key => key.toLowerCase() === headerName.toLowerCase());
+        }
+        /**
+         * Sets cookies for the request
+         * @param cookies Object containing cookie name-value pairs or cookie options
+         * @returns The instance for chaining
+         */
+        withCookies(cookies) {
+            const cookieEntries = Object.entries(cookies);
+            if (cookieEntries.length === 0) {
+                return this;
+            }
+            // Get current headers or initialize empty object
+            const currentHeaders = this.requestOptions.headers || {};
+            // Get all existing cookie headers with different cases
+            const cookieValues = [];
+            const cookieHeaderKeys = [];
+            Object.keys(currentHeaders).forEach(key => {
+                if (key.toLowerCase() === "cookie") {
+                    // Don't add empty cookie values
+                    if (currentHeaders[key])
+                        cookieValues.push(currentHeaders[key]);
+                    cookieHeaderKeys.push(key);
+                }
+            });
+            // Format the new cookies
+            const cookieString = CookieUtils.formatRequestCookies(cookies);
+            // Choose which header name to use - preserve existing case if possible
+            const headerName = cookieHeaderKeys.length > 0 ? cookieHeaderKeys[0] : "Cookie";
+            // Combine all existing cookie values with the new ones
+            const combinedCookieValue = [...cookieValues, cookieString].filter(Boolean).join("; ");
+            // Create a new headers object without any cookie headers
+            const newHeaders = { ...currentHeaders };
+            cookieHeaderKeys.forEach(key => {
+                delete newHeaders[key];
+            });
+            // Set the new combined cookie header
+            this.requestOptions.headers = {
+                ...newHeaders,
+                [headerName]: combinedCookieValue,
+            };
+            return this;
+        }
+        /**
+         * Set a single cookie
+         * @param name Cookie name
+         * @param value Cookie value or options object
+         * @returns The instance for chaining
+         */
+        withCookie(name, value) {
+            return this.withCookies({ [name]: value });
+        }
+        /**
+         * Sets a CSRF token in the request headers
+         * @param token The CSRF token
+         * @param headerName The name of the header to use (default: X-CSRF-Token)
+         * @returns The instance for chaining
+         */
+        withCsrfToken(token, headerName = "X-CSRF-Token") {
+            return this.withHeaders({
+                [headerName]: token,
+            });
+        }
+        /**
+         * Disables automatic anti-CSRF protection.
+         * By default, X-Requested-With: XMLHttpRequest header is sent with all requests.
+         * @returns The instance for chaining
+         */
+        withoutCsrfProtection() {
+            this.autoApplyCsrfProtection = false;
+            return this;
+        }
+        /**
+         * Sets common security headers to help prevent CSRF attacks
+         * @returns The instance for chaining
+         */
+        withAntiCsrfHeaders() {
+            return this.withHeaders({
+                "X-Requested-With": "XMLHttpRequest",
+            });
+        }
+        /**
+         * Configure request caching behavior
+         * When enabled, responses will be cached and reused for subsequent identical requests.
+         *
+         * @param options - Cache configuration options
+         * @returns The request instance for chaining
+         *
+         * @example
+         * request.withCache({
+         *   ttl: 60000, // Cache for 1 minute
+         *   maxEntries: 100,
+         *   storage: localStorage
+         * });
+         */
+        withCache(options = {}) {
+            this.cacheEnabled = true;
+            this.cacheManager = new CacheManager(options);
+            return this;
+        }
+        /**
+         * Send the request to the specified URL
+         * This is the final method in the chain that executes the request.
+         *
+         * @param url - The URL to send the request to
+         * @returns A promise with additional methods for processing the response
+         *
+         * @example
+         * const response = await request.sendTo('/api/users');
+         * const data = await response.getJson();
+         */
+        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()) {
+                    this.withHeaders({
+                        "X-Requested-With": "XMLHttpRequest",
+                    });
+                }
+                // 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);
+                    if (!hasLocalToken) {
+                        this.withHeaders({
+                            [csrfHeaderName]: globalToken,
+                        });
+                    }
+                }
+                // 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) {
+                    if (error instanceof Error) {
+                        // If selector fails, enhance the error with the original data
+                        const enhancedError = new Error(`Data selector failed: ${error.message}. Original data: ${JSON.stringify(await basePromise.then(response => response.getJson()), null, 2)}`);
+                        enhancedError.stack = error.stack;
+                        throw enhancedError;
+                    }
+                    throw error;
+                }
+            };
+            return responsePromise;
+        }
+        /**
+         * Formats the URL with any query parameters
+         * @param url The base URL
+         * @returns The URL with query parameters appended
+         */
+        formatUrlWithQueryParams(url) {
+            if (!this.queryParams.toString()) {
+                return url;
+            }
+            try {
+                // Try to use the URL constructor (works for absolute URLs)
+                const urlObj = new URL(url);
+                // Merge our query params with any that might be in the URL already
+                this.queryParams.forEach((value, key) => {
+                    urlObj.searchParams.append(key, value);
+                });
+                return urlObj.toString();
+            }
+            catch (error) {
+                // Handle relative URLs
+                const hasExistingParams = url.includes("?");
+                const separator = hasExistingParams ? "&" : "?";
+                return `${url}${separator}${this.queryParams.toString()}`;
+            }
+        }
+        /**
+         * Executes a request with configured retry logic
+         * @param url The formatted URL to send the request to
+         * @param fetchOptions The fetch options to use
+         * @returns A wrapped response object
+         */
+        async executeWithRetries(url, fetchOptions) {
+            let attempt = 0;
+            const maxRetries = this.requestOptions.retries || 0;
+            do {
+                try {
+                    return await this.executeRequest(url, fetchOptions);
+                }
+                catch (error) {
+                    const requestError = error instanceof RequestError ? error : RequestError.networkError(url, fetchOptions.method, error);
+                    // Don't retry on timeout errors or if we've reached the max retries
+                    if (attempt >= maxRetries || requestError.timeoutError)
+                        throw requestError;
+                    attempt++;
+                    if (this.requestOptions.onRetry) {
+                        await this.requestOptions.onRetry({ attempt, error: requestError });
+                    }
+                }
+            } while (attempt <= maxRetries);
+            // If we somehow get here, we throw an error to avoid undefined behavior
+            throw new RequestError(`Max retries reached (${maxRetries}) but request still failed`, url, fetchOptions.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();
+                            }
+                        });
+                    }
+                    else {
+                        // Fallback for browsers without AbortSignal.timeout
+                        timeoutId = setTimeout(() => {
+                            if (!controller.signal.aborted) {
+                                abortedByTimeout = true;
+                                controller.abort();
+                            }
+                        }, this.requestOptions.timeout);
+                    }
+                }
+                else {
+                    timeoutId = setTimeout(() => {
+                        abortedByTimeout = true;
+                        controller.abort();
+                    }, this.requestOptions.timeout);
+                }
+            }
+            try {
+                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);
+                    }
+                    // Otherwise it's either a user-triggered abort or another network error
+                    throw RequestError.networkError(url, fetchOptions.method, error);
+                }
+                if (!response.ok) {
+                    throw RequestError.fromResponse(response, url, fetchOptions.method);
+                }
+                // Return a wrapped response instead of parsing it
+                return new ResponseWrapper(response);
+            }
+            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);
+                }
+            }
+            // 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);
+                }
+                catch (error) {
+                    // Failed to cache, but we can still return the response
+                    console.warn("Failed to cache response:", error);
+                }
+            }
+            return response;
+        }
+    }
+
+    /**
+     * Base class for requests that can have a body (POST, PUT, PATCH)
+     */
+    class BodyRequest extends BaseRequest {
+        /**
+         * Sets the body of the request
+         * @param body - The request body
+         */
+        withBody(body) {
+            this.body = body;
+            // Set body type and validate
+            if (typeof body === "string") {
+                this.bodyType = BodyType.STRING;
+                this.setContentTypeIfNeeded("text/plain");
+            }
+            else if (body !== null &&
+                typeof body === "object" &&
+                !(body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer || body instanceof URLSearchParams || body instanceof ReadableStream)) {
+                this.bodyType = BodyType.JSON;
+                this.setContentTypeIfNeeded("application/json");
+                // Validate JSON is stringifiable early
+                try {
+                    JSON.stringify(body);
+                }
+                catch (error) {
+                    throw new Error(`Failed to stringify request body: ${String(error)}`);
+                }
+            }
+            else {
+                this.bodyType = BodyType.BINARY;
+            }
+            return this;
+        }
+        setContentTypeIfNeeded(contentType) {
+            // Only set if not already set
+            const headers = this.requestOptions.headers;
+            if (!Object.keys(headers).some(header => header.toLowerCase() === "content-type")) {
+                this.withContentType(contentType);
+            }
+        }
+        /**
+         * Send the request to the specified URL
+         * Overrides the base implementation to add body handling
+         */
+        sendTo(url) {
+            if (this.body !== undefined) {
+                // Remove previous body if it exists
+                if (this.requestOptions.body)
+                    delete this.requestOptions.body;
+                // Process the body based on its type
+                if (this.bodyType === BodyType.JSON) {
+                    this.requestOptions.body = JSON.stringify(this.body);
+                }
+                else {
+                    this.requestOptions.body = this.body;
+                }
+            }
+            return super.sendTo(url);
+        }
+    }
+
+    /**
+     * HTTP GET request implementation
+     * Used for retrieving data from an API endpoint.
+     *
+     * @example
+     * const request = new GetRequest()
+     *   .withQueryParams({ id: '123' })
+     *   .sendTo('/api/users');
+     */
+    class GetRequest extends BaseRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.GET;
+        }
+    }
+    /**
+     * HTTP HEAD request implementation
+     * Similar to GET but returns only headers without a response body.
+     *
+     * @example
+     * const request = new HeadRequest()
+     *   .sendTo('/api/users/123');
+     */
+    class HeadRequest extends BaseRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.HEAD;
+        }
+    }
+    /**
+     * HTTP OPTIONS request implementation
+     * Used to describe the communication options for the target resource.
+     *
+     * @example
+     * const request = new OptionsRequest()
+     *   .sendTo('/api/users');
+     */
+    class OptionsRequest extends BaseRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.OPTIONS;
+        }
+    }
+    /**
+     * HTTP DELETE request implementation
+     * Used to delete a resource on the server.
+     *
+     * @example
+     * const request = new DeleteRequest()
+     *   .sendTo('/api/users/123');
+     */
+    class DeleteRequest extends BaseRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.DELETE;
+        }
+    }
+    /**
+     * HTTP POST request implementation
+     * 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');
+     */
+    class PostRequest extends BodyRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.POST;
+        }
+    }
+    /**
+     * HTTP PUT request implementation
+     * 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');
+     */
+    class PutRequest extends BodyRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.PUT;
+        }
+    }
+    /**
+     * HTTP PATCH request implementation
+     * Used to apply partial modifications to a resource.
+     *
+     * @example
+     * const request = new PatchRequest()
+     *   .withJson({ email: 'new.email@example.com' })
+     *   .sendTo('/api/users/123');
+     */
+    class PatchRequest extends BodyRequest {
+        constructor() {
+            super(...arguments);
+            this.method = exports.HttpMethod.PATCH;
+        }
+    }
+
+    /**
+     * Create a GET request
+     * Used for retrieving resources from the server.
+     *
+     * @returns A new GET request instance
+     *
+     * @example
+     * const users = await get()
+     *   .withQueryParams({ limit: 10 })
+     *   .sendTo('/api/users')
+     *   .getJson();
+     */
+    function get() {
+        return new GetRequest();
+    }
+    /**
+     * Create a POST request
+     * Used for creating new resources or submitting data.
+     *
+     * @returns A new POST request instance
+     *
+     * @example
+     * const newUser = await post()
+     *   .withJson({ name: 'John', email: 'john@example.com' })
+     *   .sendTo('/api/users')
+     *   .getJson();
+     */
+    function post() {
+        return new PostRequest();
+    }
+    /**
+     * Create a PUT request
+     * Used for replacing or updating an existing resource.
+     *
+     * @returns A new PUT request instance
+     *
+     * @example
+     * const updatedUser = await put()
+     *   .withJson({ name: 'John Updated', email: 'john@example.com' })
+     *   .sendTo('/api/users/123')
+     *   .getJson();
+     */
+    function put() {
+        return new PutRequest();
+    }
+    /**
+     * Create a DELETE request
+     * Used for removing resources from the server.
+     *
+     * @returns A new DELETE request instance
+     *
+     * @example
+     * await del()
+     *   .sendTo('/api/users/123')
+     *   .getJson();
+     */
+    function del() {
+        return new DeleteRequest();
+    }
+    /**
+     * Create a PATCH request
+     * Used for applying partial modifications to a resource.
+     *
+     * @returns A new PATCH request instance
+     *
+     * @example
+     * const patchedUser = await patch()
+     *   .withJson({ status: 'active' })
+     *   .sendTo('/api/users/123')
+     *   .getJson();
+     */
+    function patch() {
+        return new PatchRequest();
+    }
+    /**
+     * Create a HEAD request
+     * Similar to GET but returns only headers without a body.
+     *
+     * @returns A new HEAD request instance
+     *
+     * @example
+     * const response = await head()
+     *   .sendTo('/api/users/123');
+     * console.log(response.headers.get('Last-Modified'));
+     */
+    function head() {
+        return new HeadRequest();
+    }
+    /**
+     * Create an OPTIONS request
+     * Used to describe the communication options for a resource.
+     *
+     * @returns A new OPTIONS request instance
+     *
+     * @example
+     * const response = await options()
+     *   .sendTo('/api/users');
+     * console.log(response.headers.get('Allow'));
+     */
+    function options() {
+        return new OptionsRequest();
+    }
+
+    /**
+     * Main API object for creating HTTP requests
+     * Provides factory methods for all HTTP methods and access to global configuration.
+     *
+     * @example
+     * // Making a GET request
+     * const users = await create.get()
+     *   .withQueryParams({ limit: 10 })
+     *   .sendTo('/api/users')
+     *   .getJson();
+     *
+     * // Configure global settings
+     * create.config.setCsrfToken('token123');
+     */
+    const create = {
+        get,
+        post,
+        put,
+        del,
+        patch,
+        head,
+        options,
+        // Add configuration access
+        config: Config.getInstance(),
+    };
+
+    exports.CacheManager = CacheManager;
+    exports.CookieUtils = CookieUtils;
+    exports.DeleteRequest = DeleteRequest;
+    exports.GetRequest = GetRequest;
+    exports.HeadRequest = HeadRequest;
+    exports.OptionsRequest = OptionsRequest;
+    exports.PatchRequest = PatchRequest;
+    exports.PostRequest = PostRequest;
+    exports.PutRequest = PutRequest;
+    exports.RequestError = RequestError;
+    exports.ResponseWrapper = ResponseWrapper;
+    exports.createLocalStorageStorage = createLocalStorageStorage;
+    exports.createMemoryStorage = createMemoryStorage;
+    exports.createSessionStorageStorage = createSessionStorageStorage;
+    exports["default"] = create;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));