create-request 1.6.1 → 2.0.0-next.0

package/dist/library/index.cjs

@@ -1,2994 +0,0 @@
-'use strict';
-
-/**
- * Enum for HTTP methods
- */
-const HttpMethod = {
-    GET: "GET",
-    PUT: "PUT",
-    POST: "POST",
-    HEAD: "HEAD",
-    PATCH: "PATCH",
-    DELETE: "DELETE",
-    OPTIONS: "OPTIONS",
-};
-/**
- * Enum for request priorities
- */
-const RequestPriority = {
-    LOW: "low",
-    HIGH: "high",
-    AUTO: "auto",
-};
-/**
- * Enum for credentials policies
- */
-const CredentialsPolicy = {
-    OMIT: "omit",
-    INCLUDE: "include",
-    SAME_ORIGIN: "same-origin",
-};
-/**
- * Enum for request modes
- */
-const RequestMode = {
-    CORS: "cors",
-    NO_CORS: "no-cors",
-    SAME_ORIGIN: "same-origin",
-    NAVIGATE: "navigate",
-};
-/**
- * Enum for redirect modes
- */
-const RedirectMode = {
-    ERROR: "error",
-    FOLLOW: "follow",
-    MANUAL: "manual",
-};
-/**
- * Enum for cookie SameSite policies
- */
-const SameSitePolicy = {
-    LAX: "Lax",
-    NONE: "None",
-    STRICT: "Strict",
-};
-/**
- * Enum for body types
- */
-const BodyType = {
-    JSON: "json",
-    STRING: "string",
-    BINARY: "binary",
-};
-/**
- * Referrer policies for fetch requests
- */
-const ReferrerPolicy = {
-    ORIGIN: "origin",
-    UNSAFE_URL: "unsafe-url",
-    SAME_ORIGIN: "same-origin",
-    NO_REFERRER: "no-referrer",
-    STRICT_ORIGIN: "strict-origin",
-    ORIGIN_WHEN_CROSS_ORIGIN: "origin-when-cross-origin",
-    NO_REFERRER_WHEN_DOWNGRADE: "no-referrer-when-downgrade",
-    STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin",
-};
-/**
- * Cache modes for fetch requests
- */
-const CacheMode = {
-    RELOAD: "reload",
-    DEFAULT: "default",
-    NO_CACHE: "no-cache",
-    NO_STORE: "no-store",
-    FORCE_CACHE: "force-cache",
-    ONLY_IF_CACHED: "only-if-cached",
-};
-
-/**
- * Extract a message from an unknown thrown value
- * @internal
- */
-const errorMessage = (e) => (e instanceof Error ? e.message : String(e));
-/**
- * Coerce an unknown thrown value to an Error
- * @internal
- */
-const toError = (e) => (e instanceof Error ? e : new Error(String(e)));
-/**
- * Error class for HTTP request failures.
- * Extends the standard Error class with additional context about the failed request.
- *
- * @example
- * ```typescript
- * try {
- *   await create.get('/api/users').getJson();
- * } catch (error) {
- *    console.log(`Request failed: ${error.message}`);
- *    console.log(`URL: ${error.url}`);
- *    console.log(`Method: ${error.method}`);
- *    console.log(`Status: ${error.status}`);
- *    console.log(`Body: ${error.body}`); // Raw response body (if available)
- *    console.log(error.getJson()); // Body parsed as JSON (or undefined)
- *    console.log(`Is timeout: ${error.isTimeout}`);
- *    console.log(`Is aborted: ${error.isAborted}`);
- * }
- * ```
- */
-class RequestError extends Error {
-    /** HTTP status code if the request received a response (e.g., 404, 500) */
-    status;
-    /** The Response object if the request received a response before failing */
-    response;
-    /**
-     * The raw response body as text, if a response was received and its body could be read.
-     * `undefined` for errors without a response (network errors, timeouts, aborts)
-     * or when the body could not be read.
-     */
-    body;
-    /** The URL that was requested */
-    url;
-    /** The HTTP method that was used (e.g., 'GET', 'POST') */
-    method;
-    /** Whether the request failed due to a timeout */
-    isTimeout;
-    /** Whether the request was aborted (cancelled) */
-    isAborted;
-    /** Cached result of parsing `body` as JSON (lazily populated by getJson) */
-    _parsed;
-    /**
-     * Creates a new RequestError instance.
-     *
-     * @param message - Error message describing what went wrong
-     * @param url - The URL that was requested
-     * @param method - The HTTP method that was used
-     * @param options - Additional error context
-     * @param options.status - HTTP status code if available
-     * @param options.response - The Response object if available
-     * @param options.body - The raw response body as text, if available
-     * @param options.isTimeout - Whether this was a timeout error
-     * @param options.isAborted - Whether the request was aborted
-     * @param options.cause - The underlying error that caused this error
-     */
-    constructor(message, url, method, options = {}) {
-        super(message, { cause: options.cause });
-        this.name = "RequestError";
-        this.url = url;
-        this.method = method;
-        this.status = options.status;
-        this.response = options.response;
-        this.body = options.body;
-        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);
-    }
-    /**
-     * Parses the captured response body (`body`) as JSON.
-     * The result is cached, so repeated calls don't re-parse.
-     * This method never throws - it returns `undefined` when there is no body
-     * or the body is not valid JSON, making it safe to use in error handlers.
-     *
-     * @returns The parsed JSON body, or `undefined` if no body was captured or it isn't valid JSON
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   await create.post('/api/users').withBody(user).getJson();
-     * } catch (error) {
-     *   if (error instanceof RequestError) {
-     *     const details = error.getJson<{ message: string; code: string }>();
-     *     console.log(details?.message ?? error.body ?? error.message);
-     *   }
-     * }
-     * ```
-     */
-    getJson() {
-        if (this._parsed === undefined && this.body) {
-            try {
-                this._parsed = JSON.parse(this.body);
-            }
-            catch {
-                // Body is not valid JSON - leave parsedBody undefined
-            }
-        }
-        return this._parsed;
-    }
-    /**
-     * Safely reads the body of a Response as text without consuming it.
-     * The response is cloned before reading, so the original body remains readable.
-     * Never throws - returns `undefined` if the body is unavailable or cannot be read
-     * (e.g., already consumed, locked stream, or read failure).
-     *
-     * @param response - The Response to read the body from
-     * @returns The body as text, or `undefined` if it could not be read
-     *
-     * @example
-     * ```typescript
-     * const body = await RequestError.captureBody(response);
-     * throw RequestError.fromResponse(response, url, 'GET', body);
-     * ```
-     */
-    static async captureBody(response) {
-        try {
-            if (!response.bodyUsed)
-                return await response.clone().text();
-        }
-        catch {
-            // Body could not be read (e.g., locked stream or read failure)
-        }
-        return undefined;
-    }
-    /**
-     * Creates a RequestError for a timeout failure.
-     *
-     * @param url - The URL that timed out
-     * @param method - The HTTP method that was used
-     * @param timeoutMs - The timeout duration in milliseconds
-     * @returns A RequestError with `isTimeout` set to `true`
-     *
-     * @example
-     * ```typescript
-     * throw RequestError.timeout('/api/data', 'GET', 5000);
-     * ```
-     */
-    static timeout(url, method, timeoutMs) {
-        return new RequestError(`Timeout:${timeoutMs}`, url, method, {
-            isTimeout: true,
-        });
-    }
-    /**
-     * Creates a RequestError from an HTTP error response.
-     * Used when the server returns a non-2xx status code.
-     *
-     * @param response - The Response object from the failed request
-     * @param url - The URL that was requested
-     * @param method - The HTTP method that was used
-     * @param body - The response body as text, if already read (see {@link RequestError.captureBody})
-     * @returns A RequestError with the status code, response object, and body (if provided)
-     *
-     * @example
-     * ```typescript
-     * const response = await fetch('/api/users');
-     * if (!response.ok) {
-     *   const body = await RequestError.captureBody(response);
-     *   throw RequestError.fromResponse(response, '/api/users', 'GET', body);
-     * }
-     * ```
-     */
-    static fromResponse(response, url, method, body) {
-        return new RequestError(`HTTP ${response.status}`, url, method, {
-            status: response.status,
-            response,
-            body,
-        });
-    }
-    /**
-     * Creates a RequestError from a network-level error.
-     * Automatically detects and categorizes common network errors (timeouts, DNS errors, connection errors).
-     *
-     * @param url - The URL that failed
-     * @param method - The HTTP method that was used
-     * @param originalError - The original error that occurred (e.g., from fetch)
-     * @returns A RequestError with enhanced error message and context
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   await fetch('/api/data');
-     * } catch (error) {
-     *   if (error instanceof Error) {
-     *     throw RequestError.networkError('/api/data', 'GET', error);
-     *   }
-     * }
-     * ```
-     */
-    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 stack = originalError.stack || "";
-        // Check for timeout errors (Node.js/undici TimeoutError)
-        // Note: While explicit timeouts set via withTimeout() are handled in BaseRequest,
-        // this detection serves as a safety net for timeout errors from external
-        // AbortControllers, other runtimes, and network-level timeouts (ETIMEDOUT).
-        const isTimeoutError = originalError.name === "TimeoutError" ||
-            message.toLowerCase().includes("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" || /getaddrinfo|ENOTFOUND|EAI_AGAIN/.test(stack);
-            // Check for connection errors (but not timeout errors)
-            const isConnectionError = !isTimeoutError && (errorCode === "ECONNREFUSED" || errorCode === "ECONNRESET" || stack.includes("ECONNREFUSED") || stack.includes("connect"));
-            message = (isTimeoutError ? "Timeout:" : isDnsError ? "DNS:" : isConnectionError ? "Conn:" : "Net:") + url;
-        }
-        const error = new RequestError(message, url, method, isTimeoutError ? { isTimeout: true } : {});
-        // Create a proper RequestError stack trace, but append the original stack for
-        // debugging context, so Node.js shows "RequestError: ..." instead of "TypeError: ..."
-        if (originalError.stack) {
-            error.stack = `${error.stack || ""}\n\nCaused by: ${originalError.stack}`;
-        }
-        return error;
-    }
-    /**
-     * Creates a RequestError for an aborted (cancelled) request.
-     *
-     * @param url - The URL that was aborted
-     * @param method - The HTTP method that was used
-     * @returns A RequestError with `isAborted` set to `true`
-     *
-     * @example
-     * ```typescript
-     * const controller = new AbortController();
-     * controller.abort();
-     * throw RequestError.abortError('/api/data', 'GET');
-     * ```
-     */
-    static abortError(url, method) {
-        return new RequestError("Aborted", url, method, {
-            isAborted: true,
-        });
-    }
-}
-
-/**
- * Wrapper for HTTP responses with methods to transform the response data.
- * Provides convenient methods to parse the response body in different formats.
- * Response bodies are cached after the first read, so you can call multiple methods
- * (e.g., `getJson()` and `getText()`) on the same response.
- *
- * @example
- * ```typescript
- * const response = await create.get('/api/users').getResponse();
- * console.log(response.status); // 200
- * console.log(response.ok); // true
- * const data = await response.getJson();
- * ```
- */
-class ResponseWrapper {
-    /** The URL that was requested (if available) */
-    url;
-    /** The HTTP method that was used (if available) */
-    method;
-    _res;
-    _gqlOpts;
-    // Cache the body as the last used method
-    _blob;
-    _text;
-    _json;
-    _buf;
-    constructor(response, url, method, graphQLOptions) {
-        this._res = response;
-        this.url = url;
-        this.method = method;
-        if (graphQLOptions) {
-            this._gqlOpts = {
-                throwOnError: graphQLOptions.throwOnError,
-            };
-        }
-    }
-    /**
-     * HTTP status code (e.g., 200, 404, 500)
-     */
-    get status() {
-        return this._res.status;
-    }
-    /**
-     * HTTP status text (e.g., "OK", "Not Found", "Internal Server Error")
-     */
-    get statusText() {
-        return this._res.statusText;
-    }
-    /**
-     * Response headers as a Headers object
-     */
-    get headers() {
-        return this._res.headers;
-    }
-    /**
-     * Whether the response status is in the 200-299 range (successful)
-     */
-    get ok() {
-        return this._res.ok;
-    }
-    /**
-     * The raw Response object from the fetch API.
-     * Use this if you need direct access to the underlying Response.
-     */
-    get raw() {
-        return this._res;
-    }
-    /**
-     * Create a RequestError carrying this response's context
-     * @param message - The error message
-     * @param withBody - Whether to attach the cached body text to the error
-     */
-    _err(message, withBody) {
-        return new RequestError(message, this.url || "", this.method || "", {
-            status: this._res.status,
-            response: this._res,
-            body: withBody ? this._text : undefined,
-        });
-    }
-    /**
-     * Read the response body via the given reader, wrapping failures in a RequestError
-     * @throws RequestError if the body has already been consumed or reading fails
-     */
-    async _read(reader) {
-        this._checkUsed();
-        try {
-            return await reader();
-        }
-        catch (e) {
-            throw this._err(`Read: ${errorMessage(e)}`);
-        }
-    }
-    /**
-     * Check if the response body has already been consumed and throw an error if so
-     * @throws RequestError if the body has already been consumed
-     */
-    _checkUsed() {
-        if (this._res.bodyUsed) {
-            throw this._err("Body used");
-        }
-    }
-    /**
-     * Check for GraphQL errors and throw if throwOnError is enabled
-     * @param data - The parsed JSON data
-     * @throws RequestError if GraphQL response contains errors and throwOnError is enabled
-     */
-    _checkGql(data) {
-        if (!this._gqlOpts?.throwOnError || typeof data !== "object" || data === null)
-            return;
-        const responseData = data;
-        if (!Array.isArray(responseData.errors) || responseData.errors.length === 0)
-            return;
-        const errors = responseData.errors;
-        const errorMessages = errors.map(x => {
-            if (typeof x === "string")
-                return x;
-            if (x && typeof x === "object" && "message" in x) {
-                const message = x.message;
-                if (message == null)
-                    return "Unknown error";
-                if (typeof message === "string")
-                    return message;
-                if (typeof message === "object") {
-                    try {
-                        return JSON.stringify(message);
-                    }
-                    catch {
-                        return "Unknown error";
-                    }
-                }
-                // For primitives (number, boolean, etc.), safe to convert
-                // eslint-disable-next-line @typescript-eslint/no-base-to-string
-                return String(message);
-            }
-            return String(x);
-        });
-        throw this._err(`GQL: ${errorMessages.join(", ")}`, true);
-    }
-    /**
-     * Parse the response body as JSON
-     * If GraphQL options are set with throwOnError=true, will check for GraphQL errors and throw.
-     *
-     * Returns `null` for empty responses (204 No Content, content-length: 0, or empty body).
-     * This handles common API patterns where PUT/DELETE operations return no content on success.
-     *
-     * @returns The parsed JSON data, or `null` for empty responses
-     * @throws {RequestError} When the request fails, JSON parsing fails, or GraphQL errors occur (if throwOnError enabled).
-     *
-     * @example
-     * const data = await response.getJson();
-     * if (data !== null) {
-     *   console.log(data.items);
-     * }
-     *
-     * @example
-     * // Error handling - errors are always RequestError
-     * try {
-     *   const data = await response.getJson();
-     * } catch (error) {
-     *   if (error instanceof RequestError) {
-     *     console.log(error.status, error.url, error.method);
-     *   }
-     * }
-     */
-    async getJson() {
-        if (this._json !== undefined)
-            return this._json;
-        // Handle empty responses: 204 No Content or content-length: 0
-        const contentLength = this._res.headers.get("content-length");
-        if (this._res.status === 204 || contentLength === "0") {
-            this._json = null;
-            return null;
-        }
-        this._checkUsed();
-        try {
-            // Read as text first to handle empty bodies and cache for getText()
-            const text = await this._res.text();
-            this._text = text;
-            // Handle empty or whitespace-only responses
-            if (!text || text.trim() === "") {
-                this._json = null;
-                return null;
-            }
-            // Parse the text as JSON
-            const parsed = JSON.parse(text);
-            this._json = parsed;
-            this._checkGql(parsed);
-            return parsed;
-        }
-        catch (error) {
-            if (error instanceof RequestError) {
-                throw error;
-            }
-            throw this._err(`Bad JSON: ${errorMessage(error)}`, true);
-        }
-    }
-    /**
-     * Get the response body as text.
-     * The result is cached, so subsequent calls return the same value without re-reading the body.
-     *
-     * @returns A promise that resolves to the response body as a string
-     * @throws {RequestError} When the body has already been consumed or reading fails
-     *
-     * @example
-     * ```typescript
-     * const text = await response.getText();
-     * console.log(text); // "Hello, world!"
-     * ```
-     */
-    async getText() {
-        if (this._text !== undefined)
-            return this._text;
-        return (this._text = await this._read(() => this._res.text()));
-    }
-    /**
-     * Get the response body as a Blob.
-     * Useful for downloading files or handling binary data.
-     * The result is cached, so subsequent calls return the same value without re-reading the body.
-     *
-     * @returns A promise that resolves to the response body as a Blob
-     * @throws {RequestError} When the body has already been consumed or reading fails
-     *
-     * @example
-     * ```typescript
-     * const blob = await response.getBlob();
-     * const url = URL.createObjectURL(blob);
-     * // Use the blob URL for downloading or displaying
-     * ```
-     */
-    async getBlob() {
-        if (this._blob !== undefined)
-            return this._blob;
-        return (this._blob = await this._read(() => this._res.blob()));
-    }
-    /**
-     * Get the response body as an ArrayBuffer.
-     * Useful for processing binary data at a low level.
-     * The result is cached, so subsequent calls return the same value without re-reading the body.
-     *
-     * @returns A promise that resolves to the response body as an ArrayBuffer
-     * @throws {RequestError} When the body has already been consumed or reading fails
-     *
-     * @example
-     * ```typescript
-     * const buffer = await response.getArrayBuffer();
-     * const uint8Array = new Uint8Array(buffer);
-     * // Process the binary data
-     * ```
-     */
-    async getArrayBuffer() {
-        if (this._buf !== undefined) {
-            return this._buf;
-        }
-        return (this._buf = await this._read(() => this._res.arrayBuffer()));
-    }
-    /**
-     * Get the raw response body as a ReadableStream
-     * Note: This consumes the response body and should only be called once.
-     * Unlike other methods, streams cannot be cached, so this will throw if the body is already consumed.
-     *
-     * @returns The response body as a ReadableStream or null
-     * @throws {RequestError} When the response body has already been consumed
-     *
-     * @example
-     * const stream = response.getBody();
-     * if (stream) {
-     *   const reader = stream.getReader();
-     *   // Process the stream
-     * }
-     */
-    getBody() {
-        this._checkUsed();
-        return this._res.body;
-    }
-    /**
-     * Extract specific data using a selector function
-     * If no selector is provided, returns the full JSON response.
-     *
-     * Returns `null` for empty responses (204 No Content, content-length: 0, or empty body).
-     * If a selector is provided and data is `null`, the selector will receive `null`.
-     *
-     * @param selector - Optional function to extract and transform data
-     * @returns A promise that resolves to the selected data, or `null` for empty responses
-     * @throws {RequestError} When the request fails, JSON parsing fails, or the selector throws an error
-     *
-     * @example
-     * // Get full response
-     * const data = await response.getData();
-     * if (data !== null) {
-     *   console.log(data.items);
-     * }
-     *
-     * @example
-     * // Extract specific data (use null-safe selector for empty responses)
-     * const users = await response.getData(data => data?.results?.users);
-     *
-     * @example
-     * // Error handling - errors are always RequestError
-     * try {
-     *   const data = await response.getData();
-     * } catch (error) {
-     *   if (error instanceof RequestError) {
-     *     console.log(error.status, error.url, error.method);
-     *   }
-     * }
-     */
-    async getData(selector) {
-        try {
-            const data = await this.getJson();
-            // If no selector is provided, return the raw JSON data (may be null)
-            if (!selector)
-                return data;
-            // Apply the selector if provided (selector receives null for empty responses)
-            return selector(data);
-        }
-        catch (error) {
-            // If it's already a RequestError, re-throw it
-            if (error instanceof RequestError) {
-                throw error;
-            }
-            // Enhance selector errors with context
-            if (selector) {
-                throw this._err(`Selector: ${errorMessage(error)}`, true);
-            }
-            // If we get here and it's not a RequestError, wrap it
-            // This should rarely happen as getJson() should throw RequestError
-            throw RequestError.networkError(this.url || "", this.method || "", toError(error));
-        }
-    }
-}
-
-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) {
-        return Object.entries(cookies)
-            .map(([name, valueOrOptions]) => `${encodeURIComponent(name)}=${encodeURIComponent(typeof valueOrOptions === "string" ? valueOrOptions : valueOrOptions.value)}`)
-            .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?.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)
-            if (!/^[A-Za-z0-9\-_=+/.]+$/.test(token)) {
-                return false;
-            }
-            // For longer tokens, check for sufficient entropy (at least 2 character types)
-            return [/[A-Z]/, /[a-z]/, /[0-9]/, /[-_=+/.]/].filter(re => re.test(token)).length >= 2;
-        }
-        // For shorter tokens (8-10 chars), just return true if we reached here
-        return true;
-    }
-}
-
-/**
- * Global configuration for create-request
- */
-class Config {
-    static _instance;
-    // CSRF configuration
-    _csrfHeader = "X-CSRF-Token";
-    _xsrfCookie = "XSRF-TOKEN";
-    _xsrfHeader = "X-XSRF-TOKEN";
-    _csrfToken = null;
-    _autoXsrf = true;
-    _antiCsrf = true; // X-Requested-With header
-    // Interceptor configuration
-    _reqI = [];
-    _resI = [];
-    _errI = [];
-    _nextId = 1;
-    constructor() { }
-    /**
-     * 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._csrfHeader = name;
-        return this;
-    }
-    /**
-     * Get the configured CSRF header name
-     *
-     * @returns The current CSRF header name
-     */
-    getCsrfHeaderName() {
-        return this._csrfHeader;
-    }
-    /**
-     * 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._xsrfCookie = name;
-        return this;
-    }
-    /**
-     * Get the configured XSRF cookie name
-     *
-     * @returns The current XSRF cookie name
-     */
-    getXsrfCookieName() {
-        return this._xsrfCookie;
-    }
-    /**
-     * 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._xsrfHeader = name;
-        return this;
-    }
-    /**
-     * Get the configured XSRF header name
-     *
-     * @returns The current XSRF header name
-     */
-    getXsrfHeaderName() {
-        return this._xsrfHeader;
-    }
-    /**
-     * 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._autoXsrf = enable;
-        return this;
-    }
-    /**
-     * Check if automatic XSRF token extraction is enabled
-     *
-     * @returns True if automatic XSRF is enabled
-     */
-    isAutoXsrfEnabled() {
-        return this._autoXsrf;
-    }
-    /**
-     * 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._antiCsrf = enable;
-        return this;
-    }
-    /**
-     * Check if anti-CSRF protection is enabled
-     *
-     * @returns True if anti-CSRF protection is enabled
-     */
-    isAntiCsrfEnabled() {
-        return this._antiCsrf;
-    }
-    /**
-     * 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._nextId++;
-        this._reqI.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._nextId++;
-        this._resI.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._nextId++;
-        this._errI.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._reqI = this._reqI.filter(item => item[0] !== id);
-    }
-    /**
-     * Remove a response interceptor by its ID
-     *
-     * @param id - The interceptor ID returned from addResponseInterceptor
-     *
-     * @example
-     * Config.getInstance().removeResponseInterceptor(id);
-     */
-    removeResponseInterceptor(id) {
-        this._resI = this._resI.filter(item => item[0] !== id);
-    }
-    /**
-     * Remove an error interceptor by its ID
-     *
-     * @param id - The interceptor ID returned from addErrorInterceptor
-     *
-     * @example
-     * Config.getInstance().removeErrorInterceptor(id);
-     */
-    removeErrorInterceptor(id) {
-        this._errI = this._errI.filter(item => item[0] !== id);
-    }
-    /**
-     * Clear all interceptors (request, response, and error)
-     *
-     * @example
-     * Config.getInstance().clearInterceptors();
-     */
-    clearInterceptors() {
-        this._reqI = [];
-        this._resI = [];
-        this._errI = [];
-    }
-    /**
-     * Get all global request interceptors (in registration order)
-     * @internal
-     */
-    getRequestInterceptors() {
-        return this._reqI.map(item => item[1]);
-    }
-    /**
-     * Get all global response interceptors (in registration order)
-     * @internal
-     */
-    getResponseInterceptors() {
-        return this._resI.map(item => item[1]);
-    }
-    /**
-     * Get all global error interceptors (in registration order)
-     * @internal
-     */
-    getErrorInterceptors() {
-        return this._errI.map(item => item[1]);
-    }
-    /**
-     * Reset all configuration options to their default values
-     *
-     * @returns The config instance for chaining
-     *
-     * @example
-     * Config.getInstance().reset();
-     */
-    reset() {
-        this._csrfToken = null;
-        this._csrfHeader = "X-CSRF-Token";
-        this._antiCsrf = true;
-        this._xsrfCookie = "XSRF-TOKEN";
-        this._xsrfHeader = "X-XSRF-TOKEN";
-        this._autoXsrf = true;
-        this.clearInterceptors();
-        return this;
-    }
-}
-
-/**
- * Base class with common functionality for all request types
- * Provides the core request building and execution capabilities.
- */
-class BaseRequest {
-    _url;
-    _opts = {
-        headers: {},
-    };
-    _ctrl;
-    _fetch;
-    _query = new URLSearchParams();
-    _autoCsrf = true;
-    // Per-request interceptors
-    _reqI = [];
-    _resI = [];
-    _errI = [];
-    constructor(url) {
-        this._url = url;
-    }
-    /**
-     * Get GraphQL options if set (only for BodyRequest subclasses)
-     * @returns GraphQL options or undefined
-     */
-    _gql() {
-        return undefined;
-    }
-    /**
-     * Creates a fluent API for setting enum-based options
-     * Combines direct setter with convenience methods
-     */
-    _fluent(optionName, options) {
-        const fluent = {};
-        // Create convenience methods for each enum value
-        Object.entries(options).forEach(([key, value]) => {
-            fluent[key] = () => {
-                this._opts[optionName] = value;
-                return this;
-            };
-        });
-        // Create the callable setter
-        const callable = (value) => {
-            this._opts[optionName] = value;
-            return this;
-        };
-        return Object.assign(callable, fluent);
-    }
-    _validateUrl(url) {
-        const errorMessage = "Bad URL";
-        if (!url?.trim())
-            throw new RequestError(errorMessage, url, this._method);
-        if (url.includes("\0") || url.includes("\r") || url.includes("\n")) {
-            throw new RequestError(errorMessage, url, this._method);
-        }
-        const trimmed = url.trim();
-        if (/^https?:\/\//.test(trimmed)) {
-            try {
-                new URL(trimmed);
-            }
-            catch {
-                throw new RequestError(errorMessage, trimmed, this._method);
-            }
-        }
-    }
-    /**
-     * 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) {
-        // Filter out null and undefined values
-        const merged = { ...this._headers() };
-        for (const [key, value] of Object.entries(headers)) {
-            if (value != null)
-                merged[key] = value;
-        }
-        this._opts.headers = merged;
-        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 RequestError if timeout is not a positive number
-     *
-     * @example
-     * request.withTimeout(5000); // 5 seconds timeout
-     */
-    withTimeout(timeout) {
-        if (!Number.isFinite(timeout) || timeout <= 0)
-            throw new RequestError("Bad timeout", this._url, this._method);
-        this._opts.timeout = timeout;
-        return this;
-    }
-    /**
-     * Configure automatic retry behavior for failed requests
-     *
-     * @param retries - Number of retry attempts before failing, or a configuration object
-     * @returns The request instance for chaining
-     * @throws RequestError if retries is not a non-negative integer or invalid config
-     *
-     * @example
-     * // Simple number (backward compatible)
-     * request.withRetries(3); // Retry up to 3 times
-     *
-     * @example
-     * // With fixed delay
-     * request.withRetries({ attempts: 3, delay: 1000 }); // Retry 3 times with 1 second delay
-     *
-     * @example
-     * // With exponential backoff function
-     * request.withRetries({
-     *   attempts: 3,
-     *   delay: ({ attempt }) => Math.min(1000 * Math.pow(2, attempt - 1), 10000)
-     * });
-     *
-     * @example
-     * // With delay function based on error
-     * request.withRetries({
-     *   attempts: 3,
-     *   delay: ({ attempt, error }) => {
-     *     if (error.status === 429) return 5000; // Rate limited, wait longer
-     *     return attempt * 1000; // Exponential backoff
-     *   }
-     * });
-     */
-    withRetries(retries) {
-        const isNumber = typeof retries === "number";
-        const attempts = isNumber ? retries : retries.attempts;
-        if (!Number.isInteger(attempts) || attempts < 0) {
-            throw new RequestError(`Bad ${isNumber ? "retries" : "attempts"}: ${attempts}`, this._url, this._method);
-        }
-        if (!isNumber && retries.delay !== undefined) {
-            const delay = retries.delay;
-            if (typeof delay === "number") {
-                if (!Number.isFinite(delay) || delay < 0)
-                    throw new RequestError(`Bad delay: ${delay}`, this._url, this._method);
-            }
-            else if (typeof delay !== "function") {
-                throw new RequestError(`Bad delay: ${typeof delay}`, this._url, this._method);
-            }
-        }
-        this._opts.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._opts.onRetry = callback;
-        return this;
-    }
-    /**
-     * Sets the credentials policy for the request, controlling whether cookies and authentication
-     * headers are sent with cross-origin requests.
-     *
-     * @param credentialsPolicy - The credentials policy to use:
-     *   - `"include"` or `CredentialsPolicy.INCLUDE`: Always send credentials (cookies, authorization headers) with the request, even for cross-origin requests.
-     *   - `"omit"` or `CredentialsPolicy.OMIT`: Never send credentials, even for same-origin requests.
-     *   - `"same-origin"` or `CredentialsPolicy.SAME_ORIGIN`: Only send credentials for same-origin requests (default behavior in most browsers).
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * // Using string values
-     * request.withCredentials("include")
-     *
-     * @example
-     * // Using enum values
-     * request.withCredentials(CredentialsPolicy.INCLUDE)
-     *
-     * @example
-     * // Using fluent API
-     * request.withCredentials.INCLUDE()
-     */
-    get withCredentials() {
-        return this._fluent("credentials", CredentialsPolicy);
-    }
-    /**
-     * Allows providing an external AbortController to cancel the request.
-     * This is useful when you need to cancel a request from outside the request chain,
-     *
-     * @param controller - The AbortController to use for this request. When `controller.abort()` is called,
-     *   the request will be cancelled and throw an abort error.
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * const controller = new AbortController();
-     * const request = createRequest('/api/data')
-     *   .withAbortController(controller)
-     *   .getJson();
-     *
-     * // Later, cancel the request
-     * controller.abort();
-     *
-     * @example
-     * // Share abort controller across multiple requests
-     * const controller = new AbortController();
-     * request1.withAbortController(controller).getJson();
-     * request2.withAbortController(controller).getJson();
-     * // Aborting will cancel both requests
-     * controller.abort();
-     */
-    withAbortController(controller) {
-        this._ctrl = controller;
-        return this;
-    }
-    /**
-     * Sets a custom fetch implementation used to execute this request.
-     * By default, requests use the global `fetch`. Injecting a custom function unlocks
-     * testing without global mocks, custom undici dispatchers/agents in Node.js,
-     * and framework-specific fetch extensions (e.g. Next.js caching options).
-     *
-     * The provided function receives the final URL and `RequestInit` (after interceptors)
-     * and must return a `Promise<Response>`. It should honor `init.signal` so that
-     * `withTimeout` and `withAbortController` keep working.
-     *
-     * @param fetchFn - A fetch-compatible function
-     * @returns The request instance for chaining
-     * @throws {RequestError} If fetchFn is not a function
-     *
-     * @example
-     * // Testing: inject a stub instead of mocking the global fetch
-     * const stubFetch: FetchFunction = async () => new Response('{"ok":true}');
-     * const data = await create.get('/api/users').withFetch(stubFetch).getJson();
-     *
-     * @example
-     * // Node.js: route through a custom undici agent (proxy, keep-alive tuning, ...)
-     * import { fetch as undiciFetch, Agent } from 'undici';
-     * const agent = new Agent({ keepAliveTimeout: 30_000 });
-     * request.withFetch((url, init) => undiciFetch(url, { ...init, dispatcher: agent }));
-     *
-     * @example
-     * // Next.js: pass caching hints through to the framework's patched fetch
-     * request.withFetch((url, init) => fetch(url, { ...init, next: { revalidate: 60 } }));
-     */
-    withFetch(fetchFn) {
-        if (typeof fetchFn !== "function")
-            throw new RequestError("Bad fetch", this._url, this._method);
-        this._fetch = fetchFn;
-        return this;
-    }
-    /**
-     * Sets the referrer URL for the request. The referrer is the URL of the page that initiated the request.
-     * This can be used to override the default referrer that the browser would normally send.
-     *
-     * @param referrer - The referrer URL to send with the request. Can be:
-     *   - A full URL (e.g., "https://example.com/page")
-     *   - An empty string to omit the referrer
-     *   - A relative URL (will be resolved relative to the current page)
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * request.withReferrer("https://example.com/previous-page")
-     *
-     * @example
-     * // Omit referrer
-     * request.withReferrer("")
-     */
-    withReferrer(referrer) {
-        this._opts.referrer = referrer;
-        return this;
-    }
-    /**
-     * Sets the referrer policy for the request, controlling how much referrer information
-     * is sent with the request. This helps balance privacy and functionality.
-     *
-     * @param policy - The referrer policy to use:
-     *   - `"no-referrer"` or `ReferrerPolicy.NO_REFERRER`: Never send the referrer header.
-     *   - `"no-referrer-when-downgrade"` or `ReferrerPolicy.NO_REFERRER_WHEN_DOWNGRADE`: Send full referrer for same-origin or HTTPS→HTTPS, omit for HTTPS→HTTP (default in most browsers).
-     *   - `"origin"` or `ReferrerPolicy.ORIGIN`: Only send the origin (scheme, host, port), not the full URL.
-     *   - `"origin-when-cross-origin"` or `ReferrerPolicy.ORIGIN_WHEN_CROSS_ORIGIN`: Send full referrer for same-origin, only origin for cross-origin.
-     *   - `"same-origin"` or `ReferrerPolicy.SAME_ORIGIN`: Send full referrer for same-origin requests only, omit for cross-origin.
-     *   - `"strict-origin"` or `ReferrerPolicy.STRICT_ORIGIN`: Send origin for HTTPS→HTTPS or HTTP→HTTP, omit for HTTPS→HTTP.
-     *   - `"strict-origin-when-cross-origin"` or `ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN`: Send full referrer for same-origin, origin for cross-origin HTTPS→HTTPS, omit for HTTPS→HTTP.
-     *   - `"unsafe-url"` or `ReferrerPolicy.UNSAFE_URL`: Always send the full referrer URL (may leak sensitive information).
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * // Using string values
-     * request.withReferrerPolicy("no-referrer")
-     *
-     * @example
-     * // Using enum values
-     * request.withReferrerPolicy(ReferrerPolicy.NO_REFERRER)
-     *
-     * @example
-     * // Using fluent API
-     * request.withReferrerPolicy.NO_REFERRER()
-     */
-    get withReferrerPolicy() {
-        return this._fluent("referrerPolicy", ReferrerPolicy);
-    }
-    /**
-     * Sets how the request handles HTTP redirects (3xx status codes).
-     *
-     * @param redirect - The redirect handling mode:
-     *   - `"follow"` or `RedirectMode.FOLLOW`: Automatically follow redirects. The fetch will transparently follow redirects and return the final response (default behavior).
-     *   - `"error"` or `RedirectMode.ERROR`: Treat redirects as errors. If a redirect occurs, the request will fail with an error.
-     *   - `"manual"` or `RedirectMode.MANUAL`: Return the redirect response without following it. The response will have a `type` of "opaqueredirect" and you can manually handle the redirect.
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * // Using string values
-     * request.withRedirect("follow")
-     *
-     * @example
-     * // Using enum values
-     * request.withRedirect(RedirectMode.FOLLOW)
-     *
-     * @example
-     * // Using fluent API
-     * request.withRedirect.FOLLOW()
-     *
-     * @example
-     * // Fail on redirects
-     * request.withRedirect.ERROR()
-     */
-    get withRedirect() {
-        return this._fluent("redirect", RedirectMode);
-    }
-    /**
-     * Sets the keepalive flag for the request. When enabled, the request can continue
-     * even after the page that initiated it is closed. This is useful for analytics,
-     * logging, or other background requests that should complete even if the user navigates away.
-     *
-     * @param keepalive - Whether to allow the request to outlive the page:
-     *   - `true`: The request will continue even if the page is closed or navigated away.
-     *   - `false`: The request will be cancelled if the page is closed (default).
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * // Send analytics event that should complete even if user navigates away
-     * request.withKeepAlive(true)
-     */
-    withKeepAlive(keepalive) {
-        this._opts.keepalive = keepalive;
-        return this;
-    }
-    /**
-     * Sets the priority hint for the request, indicating to the browser how important
-     * this request is relative to other requests. This helps the browser optimize resource loading.
-     *
-     * @param priority - The request priority:
-     *   - `"high"` or `RequestPriority.HIGH`: High priority - the browser should prioritize this request.
-     *   - `"low"` or `RequestPriority.LOW`: Low priority - the browser can defer this request if needed.
-     *   - `"auto"` or `RequestPriority.AUTO`: Automatic priority based on the request type (default).
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * // Using string values
-     * request.withPriority("high")
-     *
-     * @example
-     * // Using enum values
-     * request.withPriority(RequestPriority.HIGH)
-     *
-     * @example
-     * // Using fluent API
-     * request.withPriority.HIGH()
-     *
-     * @example
-     * // Low priority for non-critical requests
-     * request.withPriority.LOW()
-     */
-    get withPriority() {
-        return this._fluent("priority", RequestPriority);
-    }
-    /**
-     * Sets the integrity hash for Subresource Integrity (SRI) verification.
-     * This allows the browser to verify that the fetched resource hasn't been tampered with
-     * by comparing its hash against the provided value. If the hashes don't match, the request fails.
-     *
-     * @param integrity - The integrity hash string in the format `"algorithm-hash"`:
-     *   - Example: `"sha256-abcdef1234567890..."` (SHA-256 hash)
-     *   - Example: `"sha384-abcdef1234567890..."` (SHA-384 hash)
-     *   - Example: `"sha512-abcdef1234567890..."` (SHA-512 hash)
-     *   - Multiple hashes can be separated by spaces: `"sha256-... sha384-..."`
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * request.withIntegrity("sha256-abcdef1234567890...")
-     *
-     * @example
-     * // Multiple algorithms for better compatibility
-     * request.withIntegrity("sha256-... sha384-...")
-     */
-    withIntegrity(integrity) {
-        this._opts.integrity = integrity;
-        return this;
-    }
-    /**
-     * Sets the cache mode for the request, controlling how the browser's HTTP cache
-     * is used for this request.
-     *
-     * @param cache - The cache mode:
-     *   - `"default"` or `CacheMode.DEFAULT`: Use the browser's default cache behavior. The browser will check the cache and use it if valid, otherwise fetch from network.
-     *   - `"no-store"` or `CacheMode.NO_STORE`: Never use the cache and don't store the response in cache. Always fetch from network.
-     *   - `"reload"` or `CacheMode.RELOAD`: Bypass the cache but store the response. Always fetch from network, ignoring cached responses.
-     *   - `"no-cache"` or `CacheMode.NO_CACHE`: Check the cache but revalidate with the server. Use cached response only if server confirms it's still valid.
-     *   - `"force-cache"` or `CacheMode.FORCE_CACHE`: Use the cache if available, even if stale. Only fetch from network if not in cache.
-     *   - `"only-if-cached"` or `CacheMode.ONLY_IF_CACHED`: Only use the cache. If not in cache, return an error. Never fetch from network.
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * // Using string values
-     * request.withCache("no-cache")
-     *
-     * @example
-     * // Using enum values
-     * request.withCache(CacheMode.NO_CACHE)
-     *
-     * @example
-     * // Using fluent API
-     * request.withCache.NO_CACHE()
-     *
-     * @example
-     * // Always fetch fresh data
-     * request.withCache.RELOAD()
-     *
-     * @example
-     * // Use cache only, fail if not cached
-     * request.withCache.ONLY_IF_CACHED()
-     */
-    get withCache() {
-        return this._fluent("cache", CacheMode);
-    }
-    /**
-     * Adds query parameters to the request URL.
-     * Multiple calls will append parameters. Array values will create multiple query parameters with the same key.
-     * Null and undefined values are ignored.
-     *
-     * @param params - An object containing query parameter key-value pairs.
-     *   Values can be strings, numbers, booleans, arrays (for multiple values), or null/undefined (ignored).
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * // Simple parameters
-     * request.withQueryParams({ page: 1, limit: 10, active: true });
-     * // Results in: ?page=1&limit=10&active=true
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Array values create multiple parameters
-     * request.withQueryParams({ tags: ['js', 'ts', 'node'] });
-     * // Results in: ?tags=js&tags=ts&tags=node
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Null/undefined values are ignored
-     * request.withQueryParams({ page: 1, filter: null, sort: undefined });
-     * // Results in: ?page=1
-     * ```
-     */
-    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._query.append(key, String(v)));
-            }
-            else {
-                this._query.append(key, String(value));
-            }
-        });
-        return this;
-    }
-    /**
-     * Adds a single query parameter to the request URL.
-     * Convenience method for adding one parameter at a time.
-     *
-     * @param key - The query parameter name
-     * @param value - The query parameter value. Can be a string, number, boolean, array (for multiple values), or null/undefined (ignored).
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * request.withQueryParam('page', 1).withQueryParam('limit', 10);
-     * // Results in: ?page=1&limit=10
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Array values create multiple parameters
-     * request.withQueryParam('tags', ['js', 'ts']);
-     * // Results in: ?tags=js&tags=ts
-     * ```
-     */
-    withQueryParam(key, value) {
-        return this.withQueryParams({ [key]: value });
-    }
-    /**
-     * Sets the request mode, which determines the CORS (Cross-Origin Resource Sharing) behavior
-     * for the request. This controls how the browser handles cross-origin requests.
-     *
-     * @param mode - The request mode:
-     *   - `"cors"` or `RequestMode.CORS`: Enable CORS. The browser will send CORS headers and enforce CORS rules. This is the default for most cross-origin requests.
-     *   - `"no-cors"` or `RequestMode.NO_CORS`: Disable CORS. The request is sent as a "simple" request without CORS headers. The response will be opaque (you can't read it).
-     *   - `"same-origin"` or `RequestMode.SAME_ORIGIN`: Only allow same-origin requests. Cross-origin requests will fail.
-     *   - `"navigate"` or `RequestMode.NAVIGATE`: Used for navigation requests (typically only used by the browser itself).
-     *
-     * @returns The request instance for chaining
-     *
-     * @example
-     * // Using string values
-     * request.withMode("cors")
-     *
-     * @example
-     * // Using enum values
-     * request.withMode(RequestMode.CORS)
-     *
-     * @example
-     * // Using fluent API
-     * request.withMode.CORS()
-     *
-     * @example
-     * // Restrict to same-origin only
-     * request.withMode.SAME_ORIGIN()
-     */
-    get withMode() {
-        return this._fluent("mode", RequestMode);
-    }
-    /**
-     * Sets the Content-Type header for the request.
-     * Shorthand for `withHeader('Content-Type', contentType)`.
-     *
-     * @param contentType - The MIME type (e.g., `'application/json'`, `'text/plain'`, `'multipart/form-data'`)
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * request.withContentType('application/json');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * request.withContentType('application/xml');
-     * ```
-     */
-    withContentType(contentType) {
-        return this.withHeader("Content-Type", contentType);
-    }
-    /**
-     * Sets the Authorization header for the request.
-     * Shorthand for `withHeader('Authorization', authValue)`.
-     * For Bearer tokens, use `withBearerToken()` instead. For Basic auth, use `withBasicAuth()`.
-     *
-     * @param authValue - The full authorization header value (e.g., `'Bearer token123'`, `'Basic base64string'`)
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * request.withAuthorization('Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * request.withAuthorization('CustomScheme customToken');
-     * ```
-     */
-    withAuthorization(authValue) {
-        return this.withHeader("Authorization", authValue);
-    }
-    /**
-     * Sets up HTTP Basic Authentication.
-     * Encodes the username and password in base64 and sets the Authorization header.
-     *
-     * @param username - The username for Basic authentication
-     * @param password - The password for Basic authentication
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * request.withBasicAuth('myuser', 'mypassword');
-     * // Sets: Authorization: Basic bXl1c2VyOm15cGFzc3dvcmQ=
-     * ```
-     */
-    withBasicAuth(username, password) {
-        const credentials = this._b64(`${username}:${password}`);
-        return this.withAuthorization(`Basic ${credentials}`);
-    }
-    /**
-     * Cross-environment base64 encoding
-     * Works in both browser and Node.js environments
-     */
-    _b64(str) {
-        // Modern approach using TextEncoder (available in both modern browsers and Node.js)
-        if (typeof btoa === "function") {
-            if (typeof TextEncoder !== "undefined")
-                return btoa(String.fromCharCode(...new TextEncoder().encode(str)));
-            // Browser environment without TextEncoder
-            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 RequestError("No encoder", this._url, this._method);
-    }
-    /**
-     * Sets a Bearer token for authentication.
-     * Shorthand for `withAuthorization('Bearer ' + token)`.
-     *
-     * @param token - The Bearer token (JWT, OAuth token, etc.)
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * request.withBearerToken('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...');
-     * // Sets: Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
-     * ```
-     */
-    withBearerToken(token) {
-        return this.withAuthorization(`Bearer ${token}`);
-    }
-    /**
-     * Safely get headers as a Record<string, string>
-     * @returns The headers object
-     */
-    _headers() {
-        if (typeof this._opts.headers === "object" && this._opts.headers !== null) {
-            return this._opts.headers;
-        }
-        return {};
-    }
-    /**
-     * Helper function to check for header presence in a case-insensitive way
-     * @param headerName Header name to check
-     * @returns Boolean indicating if the header exists (case-insensitive)
-     */
-    _hasHeader(headerName) {
-        const headers = this._headers();
-        return Object.keys(headers).some(key => key.toLowerCase() === headerName.toLowerCase());
-    }
-    /**
-     * Sets cookies for the request.
-     * Cookies are sent in the Cookie header. Multiple calls will merge cookies.
-     * Cookie values can be simple strings or objects with additional cookie options.
-     *
-     * @param cookies - An object where keys are cookie names and values are either:
-     *   - A string (the cookie value)
-     *   - A CookieOptions object with `value` and optional properties (secure, httpOnly, sameSite, expires, path, domain, maxAge)
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * // Simple string cookies
-     * request.withCookies({ sessionId: 'abc123', userId: '456' });
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Cookies with options (note: options are for documentation only in request cookies)
-     * request.withCookies({
-     *   sessionId: 'abc123',
-     *   token: { value: 'xyz789', secure: true }
-     * });
-     * ```
-     */
-    withCookies(cookies) {
-        if (Object.keys(cookies || {}).length === 0)
-            return this;
-        // Collect existing cookie header values (any casing), preserving the first header's case
-        const newHeaders = { ...this._headers() };
-        const cookieValues = [];
-        let headerName = "";
-        for (const key of Object.keys(newHeaders)) {
-            if (key.toLowerCase() === "cookie") {
-                // Don't add empty cookie values
-                if (newHeaders[key])
-                    cookieValues.push(newHeaders[key]);
-                headerName ||= key;
-                delete newHeaders[key];
-            }
-        }
-        // Combine all existing cookie values with the newly formatted ones
-        cookieValues.push(CookieUtils.formatRequestCookies(cookies));
-        this._opts.headers = {
-            ...newHeaders,
-            [headerName || "Cookie"]: cookieValues.filter(Boolean).join("; "),
-        };
-        return this;
-    }
-    /**
-     * Sets a single cookie for the request.
-     * Convenience method for adding one cookie at a time.
-     *
-     * @param name - The cookie name
-     * @param value - The cookie value as a string, or a CookieOptions object with `value` and optional properties
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * request.withCookie('sessionId', 'abc123');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * request.withCookie('token', { value: 'xyz789', secure: true });
-     * ```
-     */
-    withCookie(name, value) {
-        return this.withCookies({ [name]: value });
-    }
-    /**
-     * Sets a CSRF (Cross-Site Request Forgery) token in the request headers.
-     * This is commonly used to protect against CSRF attacks in web applications.
-     *
-     * @param token - The CSRF token value
-     * @param headerName - The name of the header to use. Defaults to `'X-CSRF-Token'`.
-     * @returns The request instance for chaining
-     *
-     * @example
-     * ```typescript
-     * request.withCsrfToken('csrf-token-123');
-     * // Sets: X-CSRF-Token: csrf-token-123
-     * ```
-     *
-     * @example
-     * ```typescript
-     * request.withCsrfToken('token', 'X-Custom-CSRF-Header');
-     * // Sets: X-Custom-CSRF-Header: token
-     * ```
-     */
-    withCsrfToken(token, headerName = "X-CSRF-Token") {
-        return this.withHeader(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._autoCsrf = false;
-        return this;
-    }
-    /**
-     * Sets common security headers to help prevent CSRF attacks
-     * @returns The instance for chaining
-     */
-    withAntiCsrfHeaders() {
-        return this.withHeader("X-Requested-With", "XMLHttpRequest");
-    }
-    /**
-     * Add a request interceptor for this specific request
-     * Request interceptors can modify the request configuration or return an early response
-     *
-     * @param interceptor - The request interceptor function
-     * @returns The instance for chaining
-     *
-     * @example
-     * request.withRequestInterceptor((config) => {
-     *   config.headers['X-Custom'] = 'value';
-     *   return config;
-     * });
-     */
-    withRequestInterceptor(interceptor) {
-        this._reqI.push(interceptor);
-        return this;
-    }
-    /**
-     * Add a response interceptor for this specific request
-     * Response interceptors can transform the response
-     *
-     * @param interceptor - The response interceptor function
-     * @returns The instance for chaining
-     *
-     * @example
-     * request.withResponseInterceptor((response) => {
-     *   console.log('Status:', response.status);
-     *   return response;
-     * });
-     */
-    withResponseInterceptor(interceptor) {
-        this._resI.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._errI.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._fullUrl(this._url);
-        this._applyCsrf();
-        const fetchOptions = {
-            ...this._opts,
-            method: this._method,
-        };
-        return !this._opts.retries ? this._run(url, fetchOptions) : this._retry(url, fetchOptions);
-    }
-    /**
-     * Execute the request and parse the response as JSON
-     *
-     * Returns `null` for empty responses (204 No Content, content-length: 0, or empty body).
-     *
-     * @returns A promise that resolves to the parsed JSON data, or `null` for empty responses
-     * @throws {RequestError} When the request fails, JSON parsing fails, GraphQL errors occur (if throwOnError enabled), or body is already consumed
-     *
-     * @example
-     * const users = await request.getJson<User[]>();
-     * if (users !== null) {
-     *   users.forEach(u => console.log(u.name));
-     * }
-     *
-     * @example
-     * // Error handling - errors are always RequestError
-     * try {
-     *   const data = await request.getJson();
-     * } catch (error) {
-     *   if (error instanceof RequestError) {
-     *     console.log(error.status, error.url, error.method);
-     *   }
-     * }
-     */
-    async getJson() {
-        const response = await this.getResponse();
-        return response.getJson();
-    }
-    /**
-     * Execute the request and get the response body as text.
-     *
-     * @returns A promise that resolves to the response body as a string
-     * @throws {RequestError} When the request fails or reading the response fails
-     *
-     * @example
-     * ```typescript
-     * const text = await request.getText();
-     * console.log(text); // "Hello, world!"
-     * ```
-     */
-    async getText() {
-        const response = await this.getResponse();
-        return response.getText();
-    }
-    /**
-     * Execute the request and get the response body as a Blob.
-     * Useful for downloading files or handling binary data.
-     *
-     * @returns A promise that resolves to the response body as a Blob
-     * @throws {RequestError} When the request fails or reading the response fails
-     *
-     * @example
-     * ```typescript
-     * const blob = await request.getBlob();
-     * const url = URL.createObjectURL(blob);
-     * // Use the blob URL (e.g., for downloading or displaying)
-     * ```
-     */
-    async getBlob() {
-        const response = await this.getResponse();
-        return response.getBlob();
-    }
-    /**
-     * Execute the request and get the response body as an ArrayBuffer.
-     * Useful for processing binary data at a low level.
-     *
-     * @returns A promise that resolves to the response body as an ArrayBuffer
-     * @throws {RequestError} When the request fails or reading the response fails
-     *
-     * @example
-     * ```typescript
-     * const buffer = await request.getArrayBuffer();
-     * const uint8Array = new Uint8Array(buffer);
-     * // Process the binary data
-     * ```
-     */
-    async getArrayBuffer() {
-        const response = await this.getResponse();
-        return response.getArrayBuffer();
-    }
-    /**
-     * Execute the request and get the response body as a ReadableStream.
-     * Note: Unlike other methods, streams cannot be cached. The body can only be consumed once.
-     *
-     * @returns A promise that resolves to the response body as a ReadableStream, or `null` if the body is not available
-     * @throws {RequestError} When the request fails or the body has already been consumed
-     *
-     * @example
-     * ```typescript
-     * const stream = await request.getBody();
-     * if (stream) {
-     *   const reader = stream.getReader();
-     *   // Process the stream chunk by chunk
-     * }
-     * ```
-     */
-    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.
-     *
-     * Returns `null` for empty responses (204 No Content, content-length: 0, or empty body).
-     * If a selector is provided and data is `null`, the selector will receive `null`.
-     *
-     * @param selector - Optional function to extract and transform data (receives `null` for empty responses)
-     * @returns A promise that resolves to the selected data, or `null` for empty responses
-     * @throws {RequestError} When the request fails, JSON parsing fails, or the selector throws an error
-     *
-     * @example
-     * // Get full response
-     * const data = await request.getData();
-     * if (data !== null) {
-     *   console.log(data.items);
-     * }
-     *
-     * @example
-     * // Extract specific data (use null-safe selector for empty responses)
-     * const users = await request.getData(data => data?.results?.users);
-     *
-     * @example
-     * // Error handling - errors are always RequestError
-     * try {
-     *   const data = await request.getData();
-     * } catch (error) {
-     *   if (error instanceof RequestError) {
-     *     console.log(error.status, error.url, error.method);
-     *   }
-     * }
-     */
-    async getData(selector) {
-        const response = await this.getResponse();
-        return response.getData(selector);
-    }
-    /**
-     * Apply CSRF protection headers based on configuration
-     */
-    _applyCsrf() {
-        if (!this._autoCsrf)
-            return;
-        const config = Config.getInstance();
-        // Apply anti-CSRF headers if enabled
-        if (config.isAntiCsrfEnabled()) {
-            this.withAntiCsrfHeaders();
-        }
-        // 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.withHeader(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 xsrfHeaderName = config.getXsrfHeaderName();
-                const hasLocalToken = this._hasHeader("X-XSRF-TOKEN") || this._hasHeader(xsrfHeaderName);
-                if (!hasLocalToken) {
-                    this.withHeader(xsrfHeaderName, xsrfToken);
-                }
-            }
-        }
-    }
-    /**
-     * Formats the URL with any query parameters
-     * @param url The base URL
-     * @returns The URL with query parameters appended
-     */
-    _fullUrl(url) {
-        const queryString = this._query.toString();
-        if (!queryString) {
-            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._query.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}${queryString}`;
-        }
-    }
-    /**
-     * 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
-     * @throws RequestError if the request fails after all retries
-     */
-    async _retry(url, fetchOptions) {
-        const retriesConfig = this._opts.retries;
-        const maxRetries = typeof retriesConfig === "number" ? retriesConfig : retriesConfig?.attempts || 0;
-        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                return await this._run(url, fetchOptions);
-            }
-            catch (error) {
-                const requestError = error instanceof RequestError ? error : RequestError.networkError(url, method, toError(error));
-                if (attempt >= maxRetries)
-                    throw requestError;
-                // Call onRetry callback if provided
-                if (this._opts.onRetry) {
-                    await this._opts.onRetry({ attempt: attempt + 1, error: requestError });
-                }
-                // Apply delay if configured
-                if (typeof retriesConfig === "object" && retriesConfig.delay !== undefined) {
-                    const delay = typeof retriesConfig.delay === "function" ? retriesConfig.delay({ attempt: attempt + 1, error: requestError }) : retriesConfig.delay;
-                    // Validate delay result
-                    if (typeof delay !== "number" || !Number.isFinite(delay) || delay < 0) {
-                        throw new RequestError(`Bad delay: ${delay}`, url, method);
-                    }
-                    // Wait for the delay
-                    if (delay > 0) {
-                        await new Promise(resolve => setTimeout(resolve, delay));
-                    }
-                }
-            }
-        }
-        // This should never happen but is needed for type safety
-        throw new RequestError(`EO`, url, method);
-    }
-    /**
-     * 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 _runReqI(configParam) {
-        const globalConfig = Config.getInstance();
-        const allInterceptors = [...globalConfig.getRequestInterceptors(), ...this._reqI];
-        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) {
-                throw new RequestError(`ReqI: ${errorMessage(error)}`, 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 _runResI(response) {
-        const globalConfig = Config.getInstance();
-        const globalInterceptors = globalConfig.getResponseInterceptors();
-        // Per-request in order, then global in reverse
-        const allInterceptors = [...this._resI, ...[...globalInterceptors].reverse()];
-        let currentResponse = response;
-        for (let i = 0; i < allInterceptors.length; i++) {
-            try {
-                currentResponse = await allInterceptors[i](currentResponse);
-            }
-            catch (error) {
-                throw new RequestError(`ResI: ${errorMessage(error)}`, currentResponse.url || "", currentResponse.method || "");
-            }
-        }
-        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 _runErrI(error) {
-        const globalConfig = Config.getInstance();
-        const globalInterceptors = globalConfig.getErrorInterceptors();
-        // Per-request in order, then global in reverse
-        const allInterceptors = [...this._errI, ...[...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 if (currentError instanceof RequestError) {
-                    // Always wrap in RequestError when we have context
-                    currentError = new RequestError(`ErrI${i + 1}: ${errorMessage(interceptorError)}`, currentError.url, currentError.method, {
-                        status: currentError.status,
-                        response: currentError.response,
-                        body: currentError.body,
-                    });
-                }
-                else {
-                    /* c8 ignore start */
-                    // 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
-                    currentError = RequestError.networkError(error.url, error.method, toError(interceptorError));
-                    /* c8 ignore end */
-                }
-            }
-        }
-        return currentError;
-    }
-    /**
-     * Helper to create an abort signal with timeout support
-     * Handles various AbortSignal API levels gracefully
-     */
-    _signal(timeoutMs, externalController) {
-        let timeoutId;
-        let timeoutController;
-        let isTimeout = false;
-        // No timeout - just use external controller
-        if (!timeoutMs) {
-            return {
-                signal: 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(() => {
-                    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._combine(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
-     */
-    _combine(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
-     */
-    _config(url, fetchOptions) {
-        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
-        const headers = this._headers();
-        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,
-            integrity: fetchOptions.integrity,
-            cache: fetchOptions.cache,
-        };
-    }
-    /**
-     * Apply interceptor results back to fetchOptions
-     */
-    _applyConfig(config, fetchOptions) {
-        fetchOptions.headers = config.headers;
-        if (config.body !== undefined) {
-            fetchOptions.body = config.body;
-        }
-        if (config.integrity !== undefined) {
-            fetchOptions.integrity = config.integrity;
-        }
-        if (config.cache !== undefined) {
-            fetchOptions.cache = config.cache;
-        }
-    }
-    async _run(url, fetchOptions) {
-        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
-        // Setup abort signal with timeout
-        const abortSignal = this._signal(this._opts.timeout, this._ctrl);
-        try {
-            // Run request interceptors before making the request
-            const requestConfig = this._config(url, fetchOptions);
-            const interceptorResult = await this._runReqI(requestConfig);
-            // If interceptor returned a Response, short-circuit and wrap it
-            if (interceptorResult instanceof Response) {
-                const graphQLOptions = this._gql();
-                const wrappedResponse = new ResponseWrapper(interceptorResult, this._url, this._method, graphQLOptions);
-                return await this._runResI(wrappedResponse);
-            }
-            // Update fetchOptions with interceptor modifications
-            url = interceptorResult.url;
-            this._validateUrl(url);
-            this._applyConfig(interceptorResult, fetchOptions);
-            // Set the combined abort signal
-            if (abortSignal.signal) {
-                fetchOptions.signal = abortSignal.signal;
-            }
-            // Execute fetch (custom implementation if provided, global fetch otherwise)
-            const fetchFn = this._fetch ?? globalThis.fetch;
-            let response;
-            try {
-                response = await fetchFn(url, fetchOptions);
-            }
-            catch (error) {
-                const errorObj = toError(error);
-                const errorName = errorObj.name;
-                const lowerMessage = errorObj.message.toLowerCase();
-                // Check if this is a timeout error from our internal timeout
-                const isOurTimeout = abortSignal.wasTimeout();
-                // Check if it's an abort error (DOMException in browsers, or AbortSignal abort)
-                if (error instanceof DOMException && error.name === "AbortError") {
-                    // If it was our timeout that caused the abort, throw timeout error
-                    if (isOurTimeout && this._opts.timeout) {
-                        throw RequestError.timeout(url, method, this._opts.timeout);
-                    }
-                    // Otherwise it's a manual abort
-                    throw RequestError.abortError(url, method);
-                }
-                // Check for Node.js/undici TimeoutError or other timeout indicators
-                // This catches timeout errors that aren't thrown as AbortError
-                const isTimeoutError = isOurTimeout || errorName === "TimeoutError" || lowerMessage.includes("timeout");
-                if (isTimeoutError && this._opts.timeout) {
-                    throw RequestError.timeout(url, method, this._opts.timeout);
-                }
-                // For other network errors, let RequestError.networkError handle them
-                // It will check for timeout patterns as a safety net (useful for external AbortControllers)
-                throw RequestError.networkError(url, method, errorObj);
-            }
-            // Status 0 indicates the request failed before receiving a proper HTTP response
-            // (e.g., CORS errors, network failures that don't throw). Treat as network error.
-            if (response.status === 0) {
-                throw RequestError.networkError(url, method, new Error("Failed with status 0 (network error or CORS blocked)"));
-            }
-            if (!response.ok) {
-                // Capture the response body so it's available on the error object
-                // (reads from a clone, so error.response remains readable)
-                throw RequestError.fromResponse(response, url, method, await RequestError.captureBody(response));
-            }
-            const graphQLOptions = this._gql();
-            const wrappedResponse = new ResponseWrapper(response, url, method, graphQLOptions);
-            return await this._runResI(wrappedResponse);
-        }
-        catch (error) {
-            // Convert to RequestError if needed
-            const requestError = error instanceof RequestError ? error : RequestError.networkError(url, method, toError(error));
-            // Run error interceptors
-            const interceptorResult = await this._runErrI(requestError);
-            // If error interceptor returned a ResponseWrapper, recover from error
-            if (interceptorResult instanceof ResponseWrapper) {
-                return interceptorResult;
-            }
-            throw interceptorResult;
-        }
-        finally {
-            abortSignal.cleanup();
-        }
-    }
-}
-
-/**
- * Base class for requests that can have a body (POST, PUT, PATCH)
- */
-class BodyRequest extends BaseRequest {
-    _body;
-    _bodyType;
-    _gqlOpts = undefined;
-    /**
-     * Sets the request body. Automatically detects the body type and sets appropriate Content-Type header.
-     * Supports JSON objects/arrays, strings, FormData, Blob, ArrayBuffer, URLSearchParams, and ReadableStream.
-     *
-     * @param body - The request body. Can be:
-     *   - A JSON-serializable object or array (automatically stringified)
-     *   - A string (sets Content-Type to `text/plain` if not already set)
-     *   - FormData, Blob, File, ArrayBuffer, TypedArray, URLSearchParams, or ReadableStream
-     * @returns The request instance for chaining
-     * @throws {RequestError} If the body is a JSON object that cannot be stringified
-     *
-     * @example
-     * ```typescript
-     * // JSON object (automatically stringified)
-     * request.withBody({ name: 'John', age: 30 });
-     *
-     * @example
-     * // JSON array
-     * request.withBody([1, 2, 3]);
-     *
-     * @example
-     * // String
-     * request.withBody('plain text');
-     *
-     * @example
-     * // FormData
-     * const formData = new FormData();
-     * formData.append('file', fileBlob);
-     * request.withBody(formData);
-     *
-     * @example
-     * // Blob
-     * request.withBody(new Blob(['content'], { type: 'text/plain' }));
-     * ```
-     */
-    withBody(body) {
-        this._body = body;
-        // Set body type and validate
-        if (typeof body === "string") {
-            this._bodyType = BodyType.STRING;
-            this._setCT("text/plain");
-        }
-        else if (body !== null &&
-            typeof body === "object" &&
-            !(body instanceof FormData ||
-                body instanceof Blob ||
-                body instanceof File ||
-                body instanceof ArrayBuffer ||
-                ArrayBuffer.isView(body) || // Handles TypedArray and DataView
-                body instanceof URLSearchParams ||
-                body instanceof ReadableStream)) {
-            this._bodyType = BodyType.JSON;
-            this._setCT("application/json");
-            // Validate JSON is stringifiable early
-            try {
-                JSON.stringify(body);
-            }
-            catch (error) {
-                throw new RequestError(`Bad JSON: ${errorMessage(error)}`, this._url, this._method);
-            }
-        }
-        else {
-            this._bodyType = BodyType.BINARY;
-        }
-        return this;
-    }
-    /**
-     * Sets a GraphQL query or mutation as the request body.
-     * Automatically formats the body as JSON and sets Content-Type to `application/json`.
-     * If `throwOnError` is enabled in options, the response will be checked for GraphQL errors
-     * and a RequestError will be thrown if any are found.
-     *
-     * @param query - The GraphQL query or mutation string (e.g., `'query { user { id } }'`)
-     * @param variables - Optional variables object to pass with the query. Must be a plain object.
-     * @param options - Optional GraphQL-specific options
-     * @param options.throwOnError - If `true`, throws a RequestError when the GraphQL response contains errors
-     * @returns The request instance for chaining
-     * @throws {RequestError} If the query is empty, variables is invalid, or JSON stringification fails
-     *
-     * @example
-     * ```typescript
-     * // Simple query with variables
-     * const request = create.post('/graphql')
-     *   .withGraphQL('query { user(id: $id) { name email } }', { id: '123' });
-     * const data = await request.getJson();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Mutation with variables
-     * const request = create.post('/graphql')
-     *   .withGraphQL('mutation { createUser(name: $name) { id } }', { name: 'John' });
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Throw error if GraphQL response contains errors
-     * const request = create.post('/graphql')
-     *   .withGraphQL('query { user { id } }', undefined, { throwOnError: true });
-     * // If the response has errors, this will throw a RequestError
-     * const data = await request.getJson();
-     * ```
-     */
-    withGraphQL(query, variables, options) {
-        if (typeof query !== "string" || query.length === 0) {
-            throw new RequestError("Bad query", this._url, this._method);
-        }
-        const graphQLBody = {
-            query: query,
-        };
-        if (variables !== undefined) {
-            if (typeof variables !== "object" || variables === null || Array.isArray(variables)) {
-                throw new RequestError("Bad vars", this._url, this._method);
-            }
-            graphQLBody.variables = variables;
-        }
-        // Store GraphQL options if provided
-        if (options !== undefined) {
-            if (typeof options !== "object" || options === null || Array.isArray(options)) {
-                throw new RequestError("Bad opts", this._url, this._method);
-            }
-            // Store only the known GraphQL options properties
-            const opts = options;
-            this._gqlOpts = {
-                throwOnError: typeof opts.throwOnError === "boolean" ? opts.throwOnError : undefined,
-            };
-        }
-        // Validate JSON is stringifiable early
-        try {
-            JSON.stringify(graphQLBody);
-        }
-        catch (error) {
-            throw new RequestError(`Bad JSON: ${errorMessage(error)}`, this._url, this._method);
-        }
-        this._body = graphQLBody;
-        this._bodyType = BodyType.JSON;
-        this._setCT("application/json");
-        return this;
-    }
-    /**
-     * Check if Content-Type header is already set (case-insensitive)
-     */
-    _hasCT() {
-        const headers = this._opts.headers;
-        if (typeof headers === "object" && headers !== null) {
-            const headersObj = headers;
-            return Object.keys(headersObj).some(header => header.toLowerCase() === "content-type");
-        }
-        return false;
-    }
-    _setCT(contentType) {
-        if (!this._hasCT()) {
-            this.withContentType(contentType);
-        }
-    }
-    /**
-     * Get the GraphQL options if set
-     * @returns The GraphQL options or undefined
-     */
-    _gql() {
-        return this._gqlOpts;
-    }
-    /**
-     * Execute the request and return the ResponseWrapper
-     * Overrides the base implementation to add body handling
-     */
-    async getResponse() {
-        if (this._body !== undefined) {
-            // Remove previous body if it exists
-            if (this._opts.body)
-                delete this._opts.body;
-            // Process the body based on its type
-            if (this._bodyType === BodyType.JSON) {
-                this._opts.body = JSON.stringify(this._body);
-            }
-            else {
-                this._opts.body = this._body;
-            }
-        }
-        return super.getResponse();
-    }
-}
-
-/**
- * HTTP GET request implementation
- * Used for retrieving data from an API endpoint.
- *
- * @example
- * const request = new GetRequest('/api/users')
- *   .withQueryParams({ id: '123' });
- * const data = await request.getData();
- */
-class GetRequest extends BaseRequest {
-    _method = HttpMethod.GET;
-}
-/**
- * HTTP HEAD request implementation
- * Similar to GET but returns only headers without a response body.
- *
- * @example
- * const request = new HeadRequest('/api/users/123');
- * const response = await request.getResponse();
- */
-class HeadRequest extends BaseRequest {
-    _method = HttpMethod.HEAD;
-}
-/**
- * HTTP OPTIONS request implementation
- * Used to describe the communication options for the target resource.
- *
- * @example
- * const request = new OptionsRequest('/api/users');
- * const response = await request.getResponse();
- */
-class OptionsRequest extends BaseRequest {
-    _method = HttpMethod.OPTIONS;
-}
-/**
- * HTTP DELETE request implementation
- * Used to delete a resource on the server.
- *
- * @example
- * const request = new DeleteRequest('/api/users/123');
- * await request.getData();
- */
-class DeleteRequest extends BaseRequest {
-    _method = HttpMethod.DELETE;
-}
-/**
- * HTTP POST request implementation
- * Used to create a new resource or submit data for processing.
- *
- * @example
- * const request = new PostRequest('/api/users')
- *   .withBody({ name: 'John', email: 'john@example.com' });
- * const data = await request.getData();
- */
-class PostRequest extends BodyRequest {
-    _method = HttpMethod.POST;
-}
-/**
- * HTTP PUT request implementation
- * Used to replace or update an existing resource.
- *
- * @example
- * const request = new PutRequest('/api/users/123')
- *   .withBody({ id: '123', name: 'John', email: 'john@example.com' });
- * const data = await request.getData();
- */
-class PutRequest extends BodyRequest {
-    _method = HttpMethod.PUT;
-}
-/**
- * HTTP PATCH request implementation
- * Used to apply partial modifications to a resource.
- *
- * @example
- * const request = new PatchRequest('/api/users/123')
- *   .withBody({ email: 'new.email@example.com' });
- * const data = await request.getData();
- */
-class PatchRequest extends BodyRequest {
-    _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 request = get('/api/users')
- *   .withQueryParams({ limit: 10 });
- * const users = await request.getData();
- */
-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 request = post('/api/users')
- *   .withBody({ name: 'John', email: 'john@example.com' });
- * const newUser = await request.getData();
- */
-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 request = put('/api/users/123')
- *   .withBody({ name: 'John Updated', email: 'john@example.com' });
- * const updatedUser = await request.getData();
- */
-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
- * const request = del('/api/users/123');
- * await request.getData();
- */
-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 request = patch('/api/users/123')
- *   .withBody({ status: 'active' });
- * const patchedUser = await request.getData();
- */
-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 request = head('/api/users/123');
- * const response = await request.getResponse();
- * console.log(response.headers.get('Last-Modified'));
- */
-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 request = options('/api/users');
- * const response = await request.getResponse();
- * console.log(response.headers.get('Allow'));
- */
-function options(url) {
-    return new OptionsRequest(url);
-}
-
-/**
- * Internal API builder implementation.
- */
-class ApiBuilderImpl {
-    _baseURL;
-    _mods = [];
-    _proxy;
-    withBaseURL(baseURL) {
-        this._baseURL = baseURL;
-        return this._getProxy();
-    }
-    _resolve(url) {
-        if (!url)
-            return this._baseURL || "";
-        if (/^https?:\/\//.test(url))
-            return url;
-        if (!this._baseURL)
-            return url;
-        return this._baseURL.replace(/\/$/, "") + (url[0] === "/" ? url : "/" + url);
-    }
-    _new(Ctor, url) {
-        const request = new Ctor(this._resolve(url));
-        for (const modifier of this._mods)
-            modifier(request);
-        return request;
-    }
-    get(url) {
-        return this._new(GetRequest, url);
-    }
-    post(url) {
-        return this._new(PostRequest, url);
-    }
-    put(url) {
-        return this._new(PutRequest, url);
-    }
-    del(url) {
-        return this._new(DeleteRequest, url);
-    }
-    patch(url) {
-        return this._new(PatchRequest, url);
-    }
-    head(url) {
-        return this._new(HeadRequest, url);
-    }
-    options(url) {
-        return this._new(OptionsRequest, url);
-    }
-    _add(modifier) {
-        this._mods.push(modifier);
-        return this._getProxy();
-    }
-    _getProxy() {
-        if (!this._proxy) {
-            this._proxy = this._mkProxy();
-        }
-        return this._proxy;
-    }
-    _mkProxy() {
-        const disallowedMethods = new Set(["withBody", "withGraphQL", "withAbortController"]);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return new Proxy(this, {
-            get(target, prop) {
-                const implTarget = target;
-                // Return undefined for disallowed methods
-                if (typeof prop === "string" && disallowedMethods.has(prop)) {
-                    return undefined;
-                }
-                // Check if it's an HTTP method - these should be called directly
-                if (prop === "get" || prop === "post" || prop === "put" || prop === "del" || prop === "patch" || prop === "head" || prop === "options") {
-                    return implTarget[prop].bind(implTarget);
-                }
-                // Check if it's a configuration method that already exists
-                if (prop === "withBaseURL") {
-                    return implTarget[prop].bind(implTarget);
-                }
-                // Check if the property exists on BaseRequest prototype
-                // If it's a 'with...' method or other chainable method, create a modifier for it
-                if (typeof prop === "string" && (prop.startsWith("with") || prop === "onRetry")) {
-                    return (...args) => {
-                        return implTarget._add((request) => {
-                            const method = request[prop];
-                            if (typeof method === "function") {
-                                method.apply(request, args);
-                            }
-                        });
-                    };
-                }
-                // For other properties, return them directly if they exist
-                const targetValue = implTarget[prop];
-                return targetValue;
-            },
-        });
-    }
-    static create() {
-        return new ApiBuilderImpl()._getProxy();
-    }
-}
-/**
- * Creates a new API builder for configuring default request settings.
- * The API builder allows you to set up a base URL, default headers, timeout,
- * and other configuration options that will be applied to all requests made through it.
- *
- * @returns A new API builder instance
- *
- * @example
- * ```typescript
- * // Create an API instance with defaults
- * const api = api()
- *   .withBaseURL('https://api.example.com')
- *   .withBearerToken('token123')
- *   .withTimeout(5000);
- *
- * // All requests will use these defaults
- * const users = await api.get('/users').getJson();
- * const newUser = await api.post('/users').withBody({ name: 'John' }).getJson();
- * ```
- *
- * @example
- * ```typescript
- * // Use without URL when baseURL is set
- * const api = api().withBaseURL('https://api.example.com');
- * const data = await api.get().getJson(); // Requests to https://api.example.com
- * ```
- *
- * @example
- * ```typescript
- * // Override defaults per request
- * const api = api()
- *   .withBaseURL('https://api.example.com')
- *   .withTimeout(5000);
- *
- * // This request uses a longer timeout
- * await api.get('/slow-endpoint').withTimeout(30000).getJson();
- * ```
- */
-function api() {
-    return ApiBuilderImpl.create();
-}
-
-/**
- * Main API object for creating HTTP requests.
- * Provides factory methods for all HTTP methods and access to global configuration.
- *
- * @example
- * ```typescript
- * import create from 'create-request';
- *
- * // Simple GET request
- * const users = await create.get('/api/users').getJson();
- *
- * // POST request with body
- * const newUser = await create.post('/api/users')
- *   .withBody({ name: 'John', email: 'john@example.com' })
- *   .getJson();
- *
- * // Configure API instance with defaults
- * const api = create.api()
- *   .withBaseURL('https://api.example.com')
- *   .withBearerToken('token123');
- *
- * const data = await api.get('/users').getJson();
- * ```
- */
-const create = {
-    api,
-    get,
-    put,
-    del,
-    post,
-    patch,
-    head,
-    options,
-    config: Config.getInstance(),
-};
-
-exports.CacheMode = CacheMode;
-exports.CookieUtils = CookieUtils;
-exports.CredentialsPolicy = CredentialsPolicy;
-exports.DeleteRequest = DeleteRequest;
-exports.GetRequest = GetRequest;
-exports.HeadRequest = HeadRequest;
-exports.HttpMethod = HttpMethod;
-exports.OptionsRequest = OptionsRequest;
-exports.PatchRequest = PatchRequest;
-exports.PostRequest = PostRequest;
-exports.PutRequest = PutRequest;
-exports.RedirectMode = RedirectMode;
-exports.ReferrerPolicy = ReferrerPolicy;
-exports.RequestError = RequestError;
-exports.RequestMode = RequestMode;
-exports.RequestPriority = RequestPriority;
-exports.ResponseWrapper = ResponseWrapper;
-exports.SameSitePolicy = SameSitePolicy;
-exports.createApi = api;
-exports.createDelete = del;
-exports.createGet = get;
-exports.createHead = head;
-exports.createOptions = options;
-exports.createPatch = patch;
-exports.createPost = post;
-exports.createPut = put;
-exports.default = create;
-//# sourceMappingURL=index.cjs.map