create-request 1.5.4 → 1.6.1

package/dist/library/index.cjs

@@ -3,98 +3,99 @@
 /**
  * Enum for HTTP methods
  */
-exports.HttpMethod = void 0;
-(function (HttpMethod) {
-    HttpMethod["GET"] = "GET";
-    HttpMethod["PUT"] = "PUT";
-    HttpMethod["POST"] = "POST";
-    HttpMethod["HEAD"] = "HEAD";
-    HttpMethod["PATCH"] = "PATCH";
-    HttpMethod["DELETE"] = "DELETE";
-    HttpMethod["OPTIONS"] = "OPTIONS";
-})(exports.HttpMethod || (exports.HttpMethod = {}));
+const HttpMethod = {
+    GET: "GET",
+    PUT: "PUT",
+    POST: "POST",
+    HEAD: "HEAD",
+    PATCH: "PATCH",
+    DELETE: "DELETE",
+    OPTIONS: "OPTIONS",
+};
 /**
  * Enum for request priorities
  */
-exports.RequestPriority = void 0;
-(function (RequestPriority) {
-    RequestPriority["LOW"] = "low";
-    RequestPriority["HIGH"] = "high";
-    RequestPriority["AUTO"] = "auto";
-})(exports.RequestPriority || (exports.RequestPriority = {}));
+const RequestPriority = {
+    LOW: "low",
+    HIGH: "high",
+    AUTO: "auto",
+};
 /**
  * Enum for credentials policies
  */
-exports.CredentialsPolicy = void 0;
-(function (CredentialsPolicy) {
-    CredentialsPolicy["OMIT"] = "omit";
-    CredentialsPolicy["INCLUDE"] = "include";
-    CredentialsPolicy["SAME_ORIGIN"] = "same-origin";
-})(exports.CredentialsPolicy || (exports.CredentialsPolicy = {}));
+const CredentialsPolicy = {
+    OMIT: "omit",
+    INCLUDE: "include",
+    SAME_ORIGIN: "same-origin",
+};
 /**
  * Enum for request modes
  */
-exports.RequestMode = void 0;
-(function (RequestMode) {
-    RequestMode["CORS"] = "cors";
-    RequestMode["NO_CORS"] = "no-cors";
-    RequestMode["SAME_ORIGIN"] = "same-origin";
-    RequestMode["NAVIGATE"] = "navigate";
-})(exports.RequestMode || (exports.RequestMode = {}));
+const RequestMode = {
+    CORS: "cors",
+    NO_CORS: "no-cors",
+    SAME_ORIGIN: "same-origin",
+    NAVIGATE: "navigate",
+};
 /**
  * Enum for redirect modes
  */
-exports.RedirectMode = void 0;
-(function (RedirectMode) {
-    RedirectMode["ERROR"] = "error";
-    RedirectMode["FOLLOW"] = "follow";
-    RedirectMode["MANUAL"] = "manual";
-})(exports.RedirectMode || (exports.RedirectMode = {}));
+const RedirectMode = {
+    ERROR: "error",
+    FOLLOW: "follow",
+    MANUAL: "manual",
+};
 /**
  * Enum for cookie SameSite policies
  */
-exports.SameSitePolicy = void 0;
-(function (SameSitePolicy) {
-    SameSitePolicy["LAX"] = "Lax";
-    SameSitePolicy["NONE"] = "None";
-    SameSitePolicy["STRICT"] = "Strict";
-})(exports.SameSitePolicy || (exports.SameSitePolicy = {}));
+const SameSitePolicy = {
+    LAX: "Lax",
+    NONE: "None",
+    STRICT: "Strict",
+};
 /**
  * Enum for body types
  */
-var BodyType;
-(function (BodyType) {
-    BodyType["JSON"] = "json";
-    BodyType["STRING"] = "string";
-    BodyType["BINARY"] = "binary";
-})(BodyType || (BodyType = {}));
+const BodyType = {
+    JSON: "json",
+    STRING: "string",
+    BINARY: "binary",
+};
 /**
  * Referrer policies for fetch requests
  */
-exports.ReferrerPolicy = void 0;
-(function (ReferrerPolicy) {
-    ReferrerPolicy["ORIGIN"] = "origin";
-    ReferrerPolicy["UNSAFE_URL"] = "unsafe-url";
-    ReferrerPolicy["SAME_ORIGIN"] = "same-origin";
-    ReferrerPolicy["NO_REFERRER"] = "no-referrer";
-    ReferrerPolicy["STRICT_ORIGIN"] = "strict-origin";
-    ReferrerPolicy["ORIGIN_WHEN_CROSS_ORIGIN"] = "origin-when-cross-origin";
-    ReferrerPolicy["NO_REFERRER_WHEN_DOWNGRADE"] = "no-referrer-when-downgrade";
-    ReferrerPolicy["STRICT_ORIGIN_WHEN_CROSS_ORIGIN"] = "strict-origin-when-cross-origin";
-})(exports.ReferrerPolicy || (exports.ReferrerPolicy = {}));
+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
  */
-exports.CacheMode = void 0;
-(function (CacheMode) {
-    CacheMode["RELOAD"] = "reload";
-    CacheMode["DEFAULT"] = "default";
-    CacheMode["NO_CACHE"] = "no-cache";
-    CacheMode["NO_STORE"] = "no-store";
-    CacheMode["FORCE_CACHE"] = "force-cache";
-    CacheMode["ONLY_IF_CACHED"] = "only-if-cached";
-})(exports.CacheMode || (exports.CacheMode = {}));
+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.
@@ -108,6 +109,8 @@ exports.CacheMode = void 0;
  *    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}`);
  * }
@@ -118,6 +121,12 @@ class RequestError extends Error {
     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') */
@@ -126,6 +135,8 @@ class RequestError extends Error {
     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.
      *
@@ -135,6 +146,7 @@ class RequestError extends Error {
      * @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
@@ -146,6 +158,7 @@ class RequestError extends Error {
         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
@@ -155,6 +168,62 @@ class RequestError extends Error {
         // 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.
      *
@@ -180,20 +249,23 @@ class RequestError extends Error {
      * @param response - The Response object from the failed request
      * @param url - The URL that was requested
      * @param method - The HTTP method that was used
-     * @returns A RequestError with the status code and response object
+     * @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) {
-     *   throw RequestError.fromResponse(response, '/api/users', 'GET');
+     *   const body = await RequestError.captureBody(response);
+     *   throw RequestError.fromResponse(response, '/api/users', 'GET', body);
      * }
      * ```
      */
-    static fromResponse(response, url, method) {
+    static fromResponse(response, url, method, body) {
         return new RequestError(`HTTP ${response.status}`, url, method, {
             status: response.status,
             response,
+            body,
         });
     }
     /**
@@ -221,55 +293,29 @@ class RequestError extends Error {
         let message = originalError.message;
         // Check for Node.js error codes (e.g., from undici/dns errors)
         const errorCode = originalError.code;
-        const errorName = originalError.name;
         const stack = originalError.stack || "";
-        const errorMessageLower = message.toLowerCase();
         // Check for timeout errors (Node.js/undici TimeoutError)
         // Note: While explicit timeouts set via withTimeout() are handled in BaseRequest,
-        // this detection serves as a safety net for:
-        // 1. Timeout errors from external AbortControllers (e.g., AbortSignal.timeout())
-        // 2. Different runtime implementations that may throw timeout errors differently
-        // 3. Network-level timeouts (ETIMEDOUT)
-        const isTimeoutError = errorName === "TimeoutError" ||
-            errorMessageLower.includes("timeout") ||
-            errorMessageLower.includes("aborted due to timeout") ||
+        // 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" ||
-                stack.includes("getaddrinfo") ||
-                stack.includes("ENOTFOUND") ||
-                stack.includes("EAI_AGAIN");
+            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"));
-            if (isTimeoutError) {
-                message = `Timeout:${url}`;
-            }
-            else if (isDnsError) {
-                message = `DNS:${url}`;
-            }
-            else if (isConnectionError) {
-                message = `Conn:${url}`;
-            }
-            else {
-                message = `Net:${url}`;
-            }
+            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
-        // This way Node.js will show "RequestError: ..." instead of "TypeError: ..."
+        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) {
-            // Get the current stack (which will start with RequestError)
-            const currentStack = error.stack || "";
-            // Append the original error's stack as "Caused by:" for debugging context
-            error.stack = `${currentStack}\n\nCaused by: ${originalError.stack}`;
+            error.stack = `${error.stack || ""}\n\nCaused by: ${originalError.stack}`;
         }
         return error;
     }
@@ -313,19 +359,19 @@ class ResponseWrapper {
     url;
     /** The HTTP method that was used (if available) */
     method;
-    response;
-    graphQLOptions;
+    _res;
+    _gqlOpts;
     // Cache the body as the last used method
-    cachedBlob;
-    cachedText;
-    cachedJson;
-    cachedArrayBuffer;
+    _blob;
+    _text;
+    _json;
+    _buf;
     constructor(response, url, method, graphQLOptions) {
-        this.response = response;
+        this._res = response;
         this.url = url;
         this.method = method;
         if (graphQLOptions) {
-            this.graphQLOptions = {
+            this._gqlOpts = {
                 throwOnError: graphQLOptions.throwOnError,
             };
         }
@@ -334,43 +380,65 @@ class ResponseWrapper {
      * HTTP status code (e.g., 200, 404, 500)
      */
     get status() {
-        return this.response.status;
+        return this._res.status;
     }
     /**
      * HTTP status text (e.g., "OK", "Not Found", "Internal Server Error")
      */
     get statusText() {
-        return this.response.statusText;
+        return this._res.statusText;
     }
     /**
      * Response headers as a Headers object
      */
     get headers() {
-        return this.response.headers;
+        return this._res.headers;
     }
     /**
      * Whether the response status is in the 200-299 range (successful)
      */
     get ok() {
-        return this.response.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.response;
+        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
      */
-    checkBodyNotConsumed() {
-        if (this.response.bodyUsed) {
-            throw new RequestError("Body used", this.url || "", this.method || "", {
-                status: this.response.status,
-                response: this.response,
-            });
+    _checkUsed() {
+        if (this._res.bodyUsed) {
+            throw this._err("Body used");
         }
     }
     /**
@@ -378,8 +446,8 @@ class ResponseWrapper {
      * @param data - The parsed JSON data
      * @throws RequestError if GraphQL response contains errors and throwOnError is enabled
      */
-    checkGraphQLErrors(data) {
-        if (!this.graphQLOptions?.throwOnError || typeof data !== "object" || data === null)
+    _checkGql(data) {
+        if (!this._gqlOpts?.throwOnError || typeof data !== "object" || data === null)
             return;
         const responseData = data;
         if (!Array.isArray(responseData.errors) || responseData.errors.length === 0)
@@ -408,11 +476,7 @@ class ResponseWrapper {
             }
             return String(x);
         });
-        const errorMessage = errorMessages.join(", ");
-        throw new RequestError(`GQL: ${errorMessage}`, this.url || "", this.method || "", {
-            status: this.response.status,
-            response: this.response,
-        });
+        throw this._err(`GQL: ${errorMessages.join(", ")}`, true);
     }
     /**
      * Parse the response body as JSON
@@ -441,38 +505,35 @@ class ResponseWrapper {
      * }
      */
     async getJson() {
-        if (this.cachedJson !== undefined)
-            return this.cachedJson;
+        if (this._json !== undefined)
+            return this._json;
         // Handle empty responses: 204 No Content or content-length: 0
-        const contentLength = this.response.headers.get("content-length");
-        if (this.response.status === 204 || contentLength === "0") {
-            this.cachedJson = null;
+        const contentLength = this._res.headers.get("content-length");
+        if (this._res.status === 204 || contentLength === "0") {
+            this._json = null;
             return null;
         }
-        this.checkBodyNotConsumed();
+        this._checkUsed();
         try {
             // Read as text first to handle empty bodies and cache for getText()
-            const text = await this.response.text();
-            this.cachedText = text;
+            const text = await this._res.text();
+            this._text = text;
             // Handle empty or whitespace-only responses
             if (!text || text.trim() === "") {
-                this.cachedJson = null;
+                this._json = null;
                 return null;
             }
             // Parse the text as JSON
             const parsed = JSON.parse(text);
-            this.cachedJson = parsed;
-            this.checkGraphQLErrors(parsed);
+            this._json = parsed;
+            this._checkGql(parsed);
             return parsed;
         }
         catch (error) {
             if (error instanceof RequestError) {
                 throw error;
             }
-            throw new RequestError(`Bad JSON: ${error instanceof Error ? error.message : String(error)}`, this.url || "", this.method || "", {
-                status: this.response.status,
-                response: this.response,
-            });
+            throw this._err(`Bad JSON: ${errorMessage(error)}`, true);
         }
     }
     /**
@@ -489,20 +550,9 @@ class ResponseWrapper {
      * ```
      */
     async getText() {
-        if (this.cachedText !== undefined)
-            return this.cachedText;
-        this.checkBodyNotConsumed();
-        try {
-            const text = await this.response.text();
-            this.cachedText = text;
-            return text;
-        }
-        catch (e) {
-            throw new RequestError(`Read: ${e instanceof Error ? e.message : String(e)}`, this.url || "", this.method || "", {
-                status: this.response.status,
-                response: this.response,
-            });
-        }
+        if (this._text !== undefined)
+            return this._text;
+        return (this._text = await this._read(() => this._res.text()));
     }
     /**
      * Get the response body as a Blob.
@@ -520,20 +570,9 @@ class ResponseWrapper {
      * ```
      */
     async getBlob() {
-        if (this.cachedBlob !== undefined)
-            return this.cachedBlob;
-        this.checkBodyNotConsumed();
-        try {
-            const blob = await this.response.blob();
-            this.cachedBlob = blob;
-            return blob;
-        }
-        catch (e) {
-            throw new RequestError(`Read: ${e instanceof Error ? e.message : String(e)}`, this.url || "", this.method || "", {
-                status: this.response.status,
-                response: this.response,
-            });
-        }
+        if (this._blob !== undefined)
+            return this._blob;
+        return (this._blob = await this._read(() => this._res.blob()));
     }
     /**
      * Get the response body as an ArrayBuffer.
@@ -551,21 +590,10 @@ class ResponseWrapper {
      * ```
      */
     async getArrayBuffer() {
-        if (this.cachedArrayBuffer !== undefined) {
-            return this.cachedArrayBuffer;
-        }
-        this.checkBodyNotConsumed();
-        try {
-            const arrayBuffer = await this.response.arrayBuffer();
-            this.cachedArrayBuffer = arrayBuffer;
-            return arrayBuffer;
-        }
-        catch (e) {
-            throw new RequestError(`Read: ${e instanceof Error ? e.message : String(e)}`, this.url || "", this.method || "", {
-                status: this.response.status,
-                response: this.response,
-            });
+        if (this._buf !== undefined) {
+            return this._buf;
         }
+        return (this._buf = await this._read(() => this._res.arrayBuffer()));
     }
     /**
      * Get the raw response body as a ReadableStream
@@ -583,8 +611,8 @@ class ResponseWrapper {
      * }
      */
     getBody() {
-        this.checkBodyNotConsumed();
-        return this.response.body;
+        this._checkUsed();
+        return this._res.body;
     }
     /**
      * Extract specific data using a selector function
@@ -634,15 +662,11 @@ class ResponseWrapper {
             }
             // Enhance selector errors with context
             if (selector) {
-                throw new RequestError(`Selector: ${error instanceof Error ? error.message : String(error)}`, this.url || "", this.method || "", {
-                    status: this.response.status,
-                    response: this.response,
-                });
+                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
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            throw RequestError.networkError(this.url || "", this.method || "", errorObj);
+            throw RequestError.networkError(this.url || "", this.method || "", toError(error));
         }
     }
 }
@@ -654,20 +678,9 @@ class CookieUtils {
      * @returns Formatted cookie string for the Cookie header
      */
     static formatRequestCookies(cookies) {
-        const cookiePairs = [];
-        Object.entries(cookies).forEach(([name, valueOrOptions]) => {
-            let value;
-            if (typeof valueOrOptions === "string") {
-                value = valueOrOptions;
-            }
-            else {
-                // Extract value from options object without validation
-                value = valueOrOptions.value;
-            }
-            // Add the cookie to the request
-            cookiePairs.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
-        });
-        return cookiePairs.join("; ");
+        return Object.entries(cookies)
+            .map(([name, valueOrOptions]) => `${encodeURIComponent(name)}=${encodeURIComponent(typeof valueOrOptions === "string" ? valueOrOptions : valueOrOptions.value)}`)
+            .join("; ");
     }
 }
 
@@ -721,17 +734,11 @@ class CsrfUtils {
         // If token is longer than 10 chars, perform additional security checks
         if (token.length > 10) {
             // Check for valid character set (alphanumeric & common token symbols)
-            const validTokenRegex = /^[A-Za-z0-9\-_=+/.]+$/;
-            if (!validTokenRegex.test(token)) {
+            if (!/^[A-Za-z0-9\-_=+/.]+$/.test(token)) {
                 return false;
             }
             // For longer tokens, check for sufficient entropy (at least 2 character types)
-            const hasUpperCase = /[A-Z]/.test(token);
-            const hasLowerCase = /[a-z]/.test(token);
-            const hasNumbers = /[0-9]/.test(token);
-            const hasSpecials = /[-_=+/.]/.test(token);
-            const characterTypesCount = [hasUpperCase, hasLowerCase, hasNumbers, hasSpecials].filter(Boolean).length;
-            return characterTypesCount >= 2;
+            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;
@@ -742,19 +749,19 @@ class CsrfUtils {
  * Global configuration for create-request
  */
 class Config {
-    static instance;
+    static _instance;
     // CSRF configuration
-    csrfHeaderName = "X-CSRF-Token";
-    xsrfCookieName = "XSRF-TOKEN";
-    xsrfHeaderName = "X-XSRF-TOKEN";
-    csrfToken = null;
-    enableAutoXsrf = true;
-    enableAntiCsrf = true; // X-Requested-With header
+    _csrfHeader = "X-CSRF-Token";
+    _xsrfCookie = "XSRF-TOKEN";
+    _xsrfHeader = "X-XSRF-TOKEN";
+    _csrfToken = null;
+    _autoXsrf = true;
+    _antiCsrf = true; // X-Requested-With header
     // Interceptor configuration
-    requestInterceptors = [];
-    responseInterceptors = [];
-    errorInterceptors = [];
-    nextInterceptorId = 1;
+    _reqI = [];
+    _resI = [];
+    _errI = [];
+    _nextId = 1;
     constructor() { }
     /**
      * Get the singleton instance of the Config class
@@ -766,10 +773,10 @@ class Config {
      * config.setCsrfToken('token123');
      */
     static getInstance() {
-        if (!Config.instance) {
-            Config.instance = new Config();
+        if (!Config._instance) {
+            Config._instance = new Config();
         }
-        return Config.instance;
+        return Config._instance;
     }
     /**
      * Set a global CSRF token to be used for all requests
@@ -781,7 +788,7 @@ class Config {
      * Config.getInstance().setCsrfToken('myToken123');
      */
     setCsrfToken(token) {
-        this.csrfToken = token;
+        this._csrfToken = token;
         return this;
     }
     /**
@@ -790,7 +797,7 @@ class Config {
      * @returns The current CSRF token or null if not set
      */
     getCsrfToken() {
-        return this.csrfToken;
+        return this._csrfToken;
     }
     /**
      * Set the CSRF header name used when sending the token
@@ -802,7 +809,7 @@ class Config {
      * Config.getInstance().setCsrfHeaderName('X-My-CSRF-Token');
      */
     setCsrfHeaderName(name) {
-        this.csrfHeaderName = name;
+        this._csrfHeader = name;
         return this;
     }
     /**
@@ -811,7 +818,7 @@ class Config {
      * @returns The current CSRF header name
      */
     getCsrfHeaderName() {
-        return this.csrfHeaderName;
+        return this._csrfHeader;
     }
     /**
      * Set the XSRF cookie name to look for when extracting tokens from cookies
@@ -823,7 +830,7 @@ class Config {
      * Config.getInstance().setXsrfCookieName('MY-XSRF-COOKIE');
      */
     setXsrfCookieName(name) {
-        this.xsrfCookieName = name;
+        this._xsrfCookie = name;
         return this;
     }
     /**
@@ -832,7 +839,7 @@ class Config {
      * @returns The current XSRF cookie name
      */
     getXsrfCookieName() {
-        return this.xsrfCookieName;
+        return this._xsrfCookie;
     }
     /**
      * Set the XSRF header name for sending tokens extracted from cookies
@@ -841,7 +848,7 @@ class Config {
      * @returns The config instance for chaining
      */
     setXsrfHeaderName(name) {
-        this.xsrfHeaderName = name;
+        this._xsrfHeader = name;
         return this;
     }
     /**
@@ -850,7 +857,7 @@ class Config {
      * @returns The current XSRF header name
      */
     getXsrfHeaderName() {
-        return this.xsrfHeaderName;
+        return this._xsrfHeader;
     }
     /**
      * Enable or disable automatic extraction of XSRF tokens from cookies
@@ -864,7 +871,7 @@ class Config {
      * Config.getInstance().setEnableAutoXsrf(false); // Disable XSRF extraction
      */
     setEnableAutoXsrf(enable) {
-        this.enableAutoXsrf = enable;
+        this._autoXsrf = enable;
         return this;
     }
     /**
@@ -873,7 +880,7 @@ class Config {
      * @returns True if automatic XSRF is enabled
      */
     isAutoXsrfEnabled() {
-        return this.enableAutoXsrf;
+        return this._autoXsrf;
     }
     /**
      * Enable or disable automatic addition of anti-CSRF headers
@@ -883,7 +890,7 @@ class Config {
      * @returns The config instance for chaining
      */
     setEnableAntiCsrf(enable) {
-        this.enableAntiCsrf = enable;
+        this._antiCsrf = enable;
         return this;
     }
     /**
@@ -892,7 +899,7 @@ class Config {
      * @returns True if anti-CSRF protection is enabled
      */
     isAntiCsrfEnabled() {
-        return this.enableAntiCsrf;
+        return this._antiCsrf;
     }
     /**
      * Add a global request interceptor
@@ -908,8 +915,8 @@ class Config {
      * });
      */
     addRequestInterceptor(interceptor) {
-        const id = this.nextInterceptorId++;
-        this.requestInterceptors.push({ id, interceptor });
+        const id = this._nextId++;
+        this._reqI.push([id, interceptor]);
         return id;
     }
     /**
@@ -926,8 +933,8 @@ class Config {
      * });
      */
     addResponseInterceptor(interceptor) {
-        const id = this.nextInterceptorId++;
-        this.responseInterceptors.push({ id, interceptor });
+        const id = this._nextId++;
+        this._resI.push([id, interceptor]);
         return id;
     }
     /**
@@ -944,8 +951,8 @@ class Config {
      * });
      */
     addErrorInterceptor(interceptor) {
-        const id = this.nextInterceptorId++;
-        this.errorInterceptors.push({ id, interceptor });
+        const id = this._nextId++;
+        this._errI.push([id, interceptor]);
         return id;
     }
     /**
@@ -957,7 +964,7 @@ class Config {
      * Config.getInstance().removeRequestInterceptor(id);
      */
     removeRequestInterceptor(id) {
-        this.requestInterceptors = this.requestInterceptors.filter(item => item.id !== id);
+        this._reqI = this._reqI.filter(item => item[0] !== id);
     }
     /**
      * Remove a response interceptor by its ID
@@ -968,7 +975,7 @@ class Config {
      * Config.getInstance().removeResponseInterceptor(id);
      */
     removeResponseInterceptor(id) {
-        this.responseInterceptors = this.responseInterceptors.filter(item => item.id !== id);
+        this._resI = this._resI.filter(item => item[0] !== id);
     }
     /**
      * Remove an error interceptor by its ID
@@ -979,7 +986,7 @@ class Config {
      * Config.getInstance().removeErrorInterceptor(id);
      */
     removeErrorInterceptor(id) {
-        this.errorInterceptors = this.errorInterceptors.filter(item => item.id !== id);
+        this._errI = this._errI.filter(item => item[0] !== id);
     }
     /**
      * Clear all interceptors (request, response, and error)
@@ -988,30 +995,30 @@ class Config {
      * Config.getInstance().clearInterceptors();
      */
     clearInterceptors() {
-        this.requestInterceptors = [];
-        this.responseInterceptors = [];
-        this.errorInterceptors = [];
+        this._reqI = [];
+        this._resI = [];
+        this._errI = [];
     }
     /**
      * Get all global request interceptors (in registration order)
      * @internal
      */
     getRequestInterceptors() {
-        return this.requestInterceptors.map(item => item.interceptor);
+        return this._reqI.map(item => item[1]);
     }
     /**
      * Get all global response interceptors (in registration order)
      * @internal
      */
     getResponseInterceptors() {
-        return this.responseInterceptors.map(item => item.interceptor);
+        return this._resI.map(item => item[1]);
     }
     /**
      * Get all global error interceptors (in registration order)
      * @internal
      */
     getErrorInterceptors() {
-        return this.errorInterceptors.map(item => item.interceptor);
+        return this._errI.map(item => item[1]);
     }
     /**
      * Reset all configuration options to their default values
@@ -1022,12 +1029,12 @@ class Config {
      * Config.getInstance().reset();
      */
     reset() {
-        this.csrfToken = null;
-        this.csrfHeaderName = "X-CSRF-Token";
-        this.enableAntiCsrf = true;
-        this.xsrfCookieName = "XSRF-TOKEN";
-        this.xsrfHeaderName = "X-XSRF-TOKEN";
-        this.enableAutoXsrf = true;
+        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;
     }
@@ -1038,53 +1045,54 @@ class Config {
  * Provides the core request building and execution capabilities.
  */
 class BaseRequest {
-    url;
-    requestOptions = {
+    _url;
+    _opts = {
         headers: {},
     };
-    abortController;
-    queryParams = new URLSearchParams();
-    autoApplyCsrfProtection = true;
+    _ctrl;
+    _fetch;
+    _query = new URLSearchParams();
+    _autoCsrf = true;
     // Per-request interceptors
-    requestInterceptors = [];
-    responseInterceptors = [];
-    errorInterceptors = [];
+    _reqI = [];
+    _resI = [];
+    _errI = [];
     constructor(url) {
-        this.url = url;
+        this._url = url;
     }
     /**
      * Get GraphQL options if set (only for BodyRequest subclasses)
      * @returns GraphQL options or undefined
      */
-    getGraphQLOptions() {
+    _gql() {
         return undefined;
     }
     /**
      * Creates a fluent API for setting enum-based options
      * Combines direct setter with convenience methods
      */
-    createFluentSetter(optionName, options) {
+    _fluent(optionName, options) {
         const fluent = {};
         // Create convenience methods for each enum value
         Object.entries(options).forEach(([key, value]) => {
             fluent[key] = () => {
-                this.requestOptions[optionName] = value;
+                this._opts[optionName] = value;
                 return this;
             };
         });
         // Create the callable setter
         const callable = (value) => {
-            this.requestOptions[optionName] = value;
+            this._opts[optionName] = value;
             return this;
         };
         return Object.assign(callable, fluent);
     }
-    validateUrl(url) {
+    _validateUrl(url) {
         const errorMessage = "Bad URL";
         if (!url?.trim())
-            throw new RequestError(errorMessage, url, this.method);
+            throw new RequestError(errorMessage, url, this._method);
         if (url.includes("\0") || url.includes("\r") || url.includes("\n")) {
-            throw new RequestError(errorMessage, url, this.method);
+            throw new RequestError(errorMessage, url, this._method);
         }
         const trimmed = url.trim();
         if (/^https?:\/\//.test(trimmed)) {
@@ -1092,7 +1100,7 @@ class BaseRequest {
                 new URL(trimmed);
             }
             catch {
-                throw new RequestError(errorMessage, trimmed, this.method);
+                throw new RequestError(errorMessage, trimmed, this._method);
             }
         }
     }
@@ -1110,16 +1118,12 @@ class BaseRequest {
      */
     withHeaders(headers) {
         // Filter out null and undefined values
-        const filteredHeaders = {};
-        Object.entries(headers).forEach(([key, value]) => {
-            if (value !== null && value !== undefined) {
-                filteredHeaders[key] = value;
-            }
-        });
-        this.requestOptions.headers = {
-            ...this.getHeadersRecord(),
-            ...filteredHeaders,
-        };
+        const merged = { ...this._headers() };
+        for (const [key, value] of Object.entries(headers)) {
+            if (value != null)
+                merged[key] = value;
+        }
+        this._opts.headers = merged;
         return this;
     }
     /**
@@ -1148,8 +1152,8 @@ class BaseRequest {
      */
     withTimeout(timeout) {
         if (!Number.isFinite(timeout) || timeout <= 0)
-            throw new RequestError("Bad timeout", this.url, this.method);
-        this.requestOptions.timeout = timeout;
+            throw new RequestError("Bad timeout", this._url, this._method);
+        this._opts.timeout = timeout;
         return this;
     }
     /**
@@ -1185,30 +1189,22 @@ class BaseRequest {
      * });
      */
     withRetries(retries) {
-        if (typeof retries === "number") {
-            if (!Number.isInteger(retries) || retries < 0) {
-                throw new RequestError(`Bad retries: ${retries}`, this.url, this.method);
-            }
-            this.requestOptions.retries = 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);
         }
-        else {
-            // Validate RetryConfig
-            if (!Number.isInteger(retries.attempts) || retries.attempts < 0) {
-                throw new RequestError(`Bad attempts: ${retries.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);
             }
-            // Validate delay if provided
-            if (retries.delay !== undefined) {
-                if (typeof retries.delay === "number") {
-                    if (!Number.isFinite(retries.delay) || retries.delay < 0) {
-                        throw new RequestError(`Bad delay: ${retries.delay}`, this.url, this.method);
-                    }
-                }
-                else if (typeof retries.delay !== "function") {
-                    throw new RequestError(`Bad delay: ${typeof retries.delay}`, this.url, this.method);
-                }
+            else if (typeof delay !== "function") {
+                throw new RequestError(`Bad delay: ${typeof delay}`, this._url, this._method);
             }
-            this.requestOptions.retries = retries;
         }
+        this._opts.retries = retries;
         return this;
     }
     /**
@@ -1225,7 +1221,7 @@ class BaseRequest {
      * });
      */
     onRetry(callback) {
-        this.requestOptions.onRetry = callback;
+        this._opts.onRetry = callback;
         return this;
     }
     /**
@@ -1252,11 +1248,7 @@ class BaseRequest {
      * request.withCredentials.INCLUDE()
      */
     get withCredentials() {
-        return this.createFluentSetter("credentials", {
-            INCLUDE: exports.CredentialsPolicy.INCLUDE,
-            OMIT: exports.CredentialsPolicy.OMIT,
-            SAME_ORIGIN: exports.CredentialsPolicy.SAME_ORIGIN,
-        });
+        return this._fluent("credentials", CredentialsPolicy);
     }
     /**
      * Allows providing an external AbortController to cancel the request.
@@ -1285,7 +1277,42 @@ class BaseRequest {
      * controller.abort();
      */
     withAbortController(controller) {
-        this.abortController = 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;
     }
     /**
@@ -1307,7 +1334,7 @@ class BaseRequest {
      * request.withReferrer("")
      */
     withReferrer(referrer) {
-        this.requestOptions.referrer = referrer;
+        this._opts.referrer = referrer;
         return this;
     }
     /**
@@ -1339,16 +1366,7 @@ class BaseRequest {
      * request.withReferrerPolicy.NO_REFERRER()
      */
     get withReferrerPolicy() {
-        return this.createFluentSetter("referrerPolicy", {
-            ORIGIN: exports.ReferrerPolicy.ORIGIN,
-            UNSAFE_URL: exports.ReferrerPolicy.UNSAFE_URL,
-            SAME_ORIGIN: exports.ReferrerPolicy.SAME_ORIGIN,
-            NO_REFERRER: exports.ReferrerPolicy.NO_REFERRER,
-            STRICT_ORIGIN: exports.ReferrerPolicy.STRICT_ORIGIN,
-            ORIGIN_WHEN_CROSS_ORIGIN: exports.ReferrerPolicy.ORIGIN_WHEN_CROSS_ORIGIN,
-            NO_REFERRER_WHEN_DOWNGRADE: exports.ReferrerPolicy.NO_REFERRER_WHEN_DOWNGRADE,
-            STRICT_ORIGIN_WHEN_CROSS_ORIGIN: exports.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
-        });
+        return this._fluent("referrerPolicy", ReferrerPolicy);
     }
     /**
      * Sets how the request handles HTTP redirects (3xx status codes).
@@ -1377,11 +1395,7 @@ class BaseRequest {
      * request.withRedirect.ERROR()
      */
     get withRedirect() {
-        return this.createFluentSetter("redirect", {
-            FOLLOW: exports.RedirectMode.FOLLOW,
-            ERROR: exports.RedirectMode.ERROR,
-            MANUAL: exports.RedirectMode.MANUAL,
-        });
+        return this._fluent("redirect", RedirectMode);
     }
     /**
      * Sets the keepalive flag for the request. When enabled, the request can continue
@@ -1399,7 +1413,7 @@ class BaseRequest {
      * request.withKeepAlive(true)
      */
     withKeepAlive(keepalive) {
-        this.requestOptions.keepalive = keepalive;
+        this._opts.keepalive = keepalive;
         return this;
     }
     /**
@@ -1430,11 +1444,7 @@ class BaseRequest {
      * request.withPriority.LOW()
      */
     get withPriority() {
-        return this.createFluentSetter("priority", {
-            HIGH: exports.RequestPriority.HIGH,
-            LOW: exports.RequestPriority.LOW,
-            AUTO: exports.RequestPriority.AUTO,
-        });
+        return this._fluent("priority", RequestPriority);
     }
     /**
      * Sets the integrity hash for Subresource Integrity (SRI) verification.
@@ -1457,7 +1467,7 @@ class BaseRequest {
      * request.withIntegrity("sha256-... sha384-...")
      */
     withIntegrity(integrity) {
-        this.requestOptions.integrity = integrity;
+        this._opts.integrity = integrity;
         return this;
     }
     /**
@@ -1495,15 +1505,7 @@ class BaseRequest {
      * request.withCache.ONLY_IF_CACHED()
      */
     get withCache() {
-        const cacheOptions = {
-            DEFAULT: "default",
-            NO_STORE: "no-store",
-            RELOAD: "reload",
-            NO_CACHE: "no-cache",
-            FORCE_CACHE: "force-cache",
-            ONLY_IF_CACHED: "only-if-cached",
-        };
-        return this.createFluentSetter("cache", cacheOptions);
+        return this._fluent("cache", CacheMode);
     }
     /**
      * Adds query parameters to the request URL.
@@ -1542,10 +1544,10 @@ class BaseRequest {
             }
             if (Array.isArray(value)) {
                 // Handle array values - add multiple entries with the same key
-                value.forEach(v => this.queryParams.append(key, String(v)));
+                value.forEach(v => this._query.append(key, String(v)));
             }
             else {
-                this.queryParams.append(key, String(value));
+                this._query.append(key, String(value));
             }
         });
         return this;
@@ -1603,12 +1605,7 @@ class BaseRequest {
      * request.withMode.SAME_ORIGIN()
      */
     get withMode() {
-        return this.createFluentSetter("mode", {
-            CORS: exports.RequestMode.CORS,
-            NO_CORS: exports.RequestMode.NO_CORS,
-            SAME_ORIGIN: exports.RequestMode.SAME_ORIGIN,
-            NAVIGATE: exports.RequestMode.NAVIGATE,
-        });
+        return this._fluent("mode", RequestMode);
     }
     /**
      * Sets the Content-Type header for the request.
@@ -1666,28 +1663,26 @@ class BaseRequest {
      * ```
      */
     withBasicAuth(username, password) {
-        const credentials = this.encodeBase64(`${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
      */
-    encodeBase64(str) {
+    _b64(str) {
         // Modern approach using TextEncoder (available in both modern browsers and Node.js)
-        if (typeof TextEncoder !== "undefined" && typeof btoa === "function") {
-            const encoder = new TextEncoder();
-            const bytes = encoder.encode(str);
-            return btoa(String.fromCharCode.apply(null, [...new Uint8Array(bytes)]));
-        }
-        // Browser environment
-        if (typeof btoa === "function")
+        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);
+        throw new RequestError("No encoder", this._url, this._method);
     }
     /**
      * Sets a Bearer token for authentication.
@@ -1709,9 +1704,9 @@ class BaseRequest {
      * Safely get headers as a Record<string, string>
      * @returns The headers object
      */
-    getHeadersRecord() {
-        if (typeof this.requestOptions.headers === "object" && this.requestOptions.headers !== null) {
-            return this.requestOptions.headers;
+    _headers() {
+        if (typeof this._opts.headers === "object" && this._opts.headers !== null) {
+            return this._opts.headers;
         }
         return {};
     }
@@ -1720,8 +1715,8 @@ class BaseRequest {
      * @param headerName Header name to check
      * @returns Boolean indicating if the header exists (case-insensitive)
      */
-    hasHeader(headerName) {
-        const headers = this.getHeadersRecord();
+    _hasHeader(headerName) {
+        const headers = this._headers();
         return Object.keys(headers).some(key => key.toLowerCase() === headerName.toLowerCase());
     }
     /**
@@ -1750,37 +1745,26 @@ class BaseRequest {
      * ```
      */
     withCookies(cookies) {
-        const cookieEntries = Object.entries(cookies || {});
-        if (cookieEntries.length === 0) {
+        if (Object.keys(cookies || {}).length === 0)
             return this;
-        }
-        const currentHeaders = this.getHeadersRecord();
-        // Get all existing cookie headers with different cases
+        // Collect existing cookie header values (any casing), preserving the first header's case
+        const newHeaders = { ...this._headers() };
         const cookieValues = [];
-        const cookieHeaderKeys = [];
-        Object.keys(currentHeaders).forEach(key => {
+        let headerName = "";
+        for (const key of Object.keys(newHeaders)) {
             if (key.toLowerCase() === "cookie") {
                 // Don't add empty cookie values
-                if (currentHeaders[key])
-                    cookieValues.push(currentHeaders[key]);
-                cookieHeaderKeys.push(key);
+                if (newHeaders[key])
+                    cookieValues.push(newHeaders[key]);
+                headerName ||= key;
+                delete newHeaders[key];
             }
-        });
-        // Format the new cookies
-        const cookieString = CookieUtils.formatRequestCookies(cookies);
-        // Choose which header name to use - preserve existing case if possible
-        const headerName = cookieHeaderKeys.length > 0 ? cookieHeaderKeys[0] : "Cookie";
-        // Combine all existing cookie values with the new ones
-        const combinedCookieValue = [...cookieValues, cookieString].filter(Boolean).join("; ");
-        // Create a new headers object without any cookie headers
-        const newHeaders = { ...currentHeaders };
-        cookieHeaderKeys.forEach(key => {
-            delete newHeaders[key];
-        });
-        // Set the new combined cookie header
-        this.requestOptions.headers = {
+        }
+        // Combine all existing cookie values with the newly formatted ones
+        cookieValues.push(CookieUtils.formatRequestCookies(cookies));
+        this._opts.headers = {
             ...newHeaders,
-            [headerName]: combinedCookieValue,
+            [headerName || "Cookie"]: cookieValues.filter(Boolean).join("; "),
         };
         return this;
     }
@@ -1834,7 +1818,7 @@ class BaseRequest {
      * @returns The instance for chaining
      */
     withoutCsrfProtection() {
-        this.autoApplyCsrfProtection = false;
+        this._autoCsrf = false;
         return this;
     }
     /**
@@ -1858,7 +1842,7 @@ class BaseRequest {
      * });
      */
     withRequestInterceptor(interceptor) {
-        this.requestInterceptors.push(interceptor);
+        this._reqI.push(interceptor);
         return this;
     }
     /**
@@ -1875,7 +1859,7 @@ class BaseRequest {
      * });
      */
     withResponseInterceptor(interceptor) {
-        this.responseInterceptors.push(interceptor);
+        this._resI.push(interceptor);
         return this;
     }
     /**
@@ -1892,7 +1876,7 @@ class BaseRequest {
      * });
      */
     withErrorInterceptor(interceptor) {
-        this.errorInterceptors.push(interceptor);
+        this._errI.push(interceptor);
         return this;
     }
     /**
@@ -1906,13 +1890,13 @@ class BaseRequest {
      * console.log(response.status);
      */
     async getResponse() {
-        const url = this.formatUrlWithQueryParams(this.url);
-        this.applyCsrfProtection();
+        const url = this._fullUrl(this._url);
+        this._applyCsrf();
         const fetchOptions = {
-            ...this.requestOptions,
-            method: this.method,
+            ...this._opts,
+            method: this._method,
         };
-        return !this.requestOptions.retries ? this.executeRequest(url, fetchOptions) : this.executeWithRetries(url, fetchOptions);
+        return !this._opts.retries ? this._run(url, fetchOptions) : this._retry(url, fetchOptions);
     }
     /**
      * Execute the request and parse the response as JSON
@@ -2053,8 +2037,8 @@ class BaseRequest {
     /**
      * Apply CSRF protection headers based on configuration
      */
-    applyCsrfProtection() {
-        if (!this.autoApplyCsrfProtection)
+    _applyCsrf() {
+        if (!this._autoCsrf)
             return;
         const config = Config.getInstance();
         // Apply anti-CSRF headers if enabled
@@ -2065,7 +2049,7 @@ class BaseRequest {
         const globalToken = config.getCsrfToken();
         if (globalToken) {
             const csrfHeaderName = config.getCsrfHeaderName();
-            const hasLocalToken = this.hasHeader("X-CSRF-Token") || this.hasHeader(csrfHeaderName);
+            const hasLocalToken = this._hasHeader("X-CSRF-Token") || this._hasHeader(csrfHeaderName);
             if (!hasLocalToken) {
                 this.withHeader(csrfHeaderName, globalToken);
             }
@@ -2075,7 +2059,7 @@ class BaseRequest {
             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);
+                const hasLocalToken = this._hasHeader("X-XSRF-TOKEN") || this._hasHeader(xsrfHeaderName);
                 if (!hasLocalToken) {
                     this.withHeader(xsrfHeaderName, xsrfToken);
                 }
@@ -2087,8 +2071,8 @@ class BaseRequest {
      * @param url The base URL
      * @returns The URL with query parameters appended
      */
-    formatUrlWithQueryParams(url) {
-        const queryString = this.queryParams.toString();
+    _fullUrl(url) {
+        const queryString = this._query.toString();
         if (!queryString) {
             return url;
         }
@@ -2096,7 +2080,7 @@ class BaseRequest {
             // Try to use the URL constructor (works for absolute URLs)
             const urlObj = new URL(url);
             // Merge our query params with any that might be in the URL already
-            this.queryParams.forEach((value, key) => {
+            this._query.forEach((value, key) => {
                 urlObj.searchParams.append(key, value);
             });
             return urlObj.toString();
@@ -2115,21 +2099,21 @@ class BaseRequest {
      * @returns A wrapped response object
      * @throws RequestError if the request fails after all retries
      */
-    async executeWithRetries(url, fetchOptions) {
-        const retriesConfig = this.requestOptions.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.executeRequest(url, fetchOptions);
+                return await this._run(url, fetchOptions);
             }
             catch (error) {
-                const requestError = error instanceof RequestError ? error : RequestError.networkError(url, method, error instanceof Error ? error : new Error(String(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.requestOptions.onRetry) {
-                    await this.requestOptions.onRetry({ attempt: attempt + 1, error: requestError });
+                if (this._opts.onRetry) {
+                    await this._opts.onRetry({ attempt: attempt + 1, error: requestError });
                 }
                 // Apply delay if configured
                 if (typeof retriesConfig === "object" && retriesConfig.delay !== undefined) {
@@ -2153,9 +2137,9 @@ class BaseRequest {
      * @param configParam - The request configuration
      * @returns Modified config or a Response to short-circuit
      */
-    async runRequestInterceptors(configParam) {
+    async _runReqI(configParam) {
         const globalConfig = Config.getInstance();
-        const allInterceptors = [...globalConfig.getRequestInterceptors(), ...this.requestInterceptors];
+        const allInterceptors = [...globalConfig.getRequestInterceptors(), ...this._reqI];
         let currentConfig = configParam;
         for (let i = 0; i < allInterceptors.length; i++) {
             try {
@@ -2167,7 +2151,7 @@ class BaseRequest {
                 currentConfig = result;
             }
             catch (error) {
-                throw new RequestError(`ReqI: ${error instanceof Error ? error.message : String(error)}`, currentConfig.url, currentConfig.method);
+                throw new RequestError(`ReqI: ${errorMessage(error)}`, currentConfig.url, currentConfig.method);
             }
         }
         return currentConfig;
@@ -2177,18 +2161,18 @@ class BaseRequest {
      * @param response - The response wrapper
      * @returns Modified response wrapper
      */
-    async runResponseInterceptors(response) {
+    async _runResI(response) {
         const globalConfig = Config.getInstance();
         const globalInterceptors = globalConfig.getResponseInterceptors();
         // Per-request in order, then global in reverse
-        const allInterceptors = [...this.responseInterceptors, ...[...globalInterceptors].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: ${error instanceof Error ? error.message : String(error)}`, currentResponse.url || "", currentResponse.method || "");
+                throw new RequestError(`ResI: ${errorMessage(error)}`, currentResponse.url || "", currentResponse.method || "");
             }
         }
         return currentResponse;
@@ -2198,11 +2182,11 @@ class BaseRequest {
      * @param error - The error that occurred
      * @returns Modified error or a ResponseWrapper to recover
      */
-    async runErrorInterceptors(error) {
+    async _runErrI(error) {
         const globalConfig = Config.getInstance();
         const globalInterceptors = globalConfig.getErrorInterceptors();
         // Per-request in order, then global in reverse
-        const allInterceptors = [...this.errorInterceptors, ...[...globalInterceptors].reverse()];
+        const allInterceptors = [...this._errI, ...[...globalInterceptors].reverse()];
         let currentError = error;
         for (let i = 0; i < allInterceptors.length; i++) {
             try {
@@ -2218,23 +2202,20 @@ class BaseRequest {
                 if (interceptorError instanceof RequestError) {
                     currentError = interceptorError;
                 }
-                else {
-                    const em = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
+                else if (currentError instanceof RequestError) {
                     // Always wrap in RequestError when we have context
-                    if (currentError instanceof RequestError) {
-                        currentError = new RequestError(`ErrI${i + 1}: ${em}`, currentError.url, currentError.method, {
-                            status: currentError.status,
-                            response: currentError.response,
-                        });
-                    }
-                    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
-                        const errorObj = interceptorError instanceof Error ? interceptorError : new Error(String(interceptorError));
-                        currentError = RequestError.networkError(error.url, error.method, errorObj);
-                        /* c8 ignore end */
-                    }
+                    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 */
                 }
             }
         }
@@ -2244,7 +2225,7 @@ class BaseRequest {
      * Helper to create an abort signal with timeout support
      * Handles various AbortSignal API levels gracefully
      */
-    createAbortSignal(timeoutMs, externalController) {
+    _signal(timeoutMs, externalController) {
         let timeoutId;
         let timeoutController;
         let isTimeout = false;
@@ -2280,7 +2261,7 @@ class BaseRequest {
         const finalSignal = externalController && hasAbortSignalAny
             ? AbortSignal.any([externalController.signal, timeoutSignal])
             : externalController
-                ? this.combineSignalsManually(externalController.signal, timeoutSignal)
+                ? this._combine(externalController.signal, timeoutSignal)
                 : timeoutSignal;
         return {
             signal: finalSignal,
@@ -2295,7 +2276,7 @@ class BaseRequest {
      * Manually combine two abort signals for older environments
      * Returns the first signal and listens to the second
      */
-    combineSignalsManually(signal1, signal2) {
+    _combine(signal1, signal2) {
         // If either is already aborted, use that one
         if (signal1.aborted)
             return signal1;
@@ -2311,9 +2292,9 @@ class BaseRequest {
     /**
      * Convert fetchOptions to RequestConfig with proper typing
      */
-    createRequestConfig(url, fetchOptions) {
+    _config(url, fetchOptions) {
         const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
-        const headers = this.getHeadersRecord();
+        const headers = this._headers();
         const extendedOptions = fetchOptions;
         return {
             url,
@@ -2335,7 +2316,7 @@ class BaseRequest {
     /**
      * Apply interceptor results back to fetchOptions
      */
-    applyRequestConfig(config, fetchOptions) {
+    _applyConfig(config, fetchOptions) {
         fetchOptions.headers = config.headers;
         if (config.body !== undefined) {
             fetchOptions.body = config.body;
@@ -2347,53 +2328,54 @@ class BaseRequest {
             fetchOptions.cache = config.cache;
         }
     }
-    async executeRequest(url, fetchOptions) {
+    async _run(url, fetchOptions) {
         const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
         // Setup abort signal with timeout
-        const abortSignal = this.createAbortSignal(this.requestOptions.timeout, this.abortController);
+        const abortSignal = this._signal(this._opts.timeout, this._ctrl);
         try {
             // Run request interceptors before making the request
-            const requestConfig = this.createRequestConfig(url, fetchOptions);
-            const interceptorResult = await this.runRequestInterceptors(requestConfig);
+            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.getGraphQLOptions();
-                const wrappedResponse = new ResponseWrapper(interceptorResult, this.url, this.method, graphQLOptions);
-                return await this.runResponseInterceptors(wrappedResponse);
+                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.applyRequestConfig(interceptorResult, fetchOptions);
+            this._validateUrl(url);
+            this._applyConfig(interceptorResult, fetchOptions);
             // Set the combined abort signal
             if (abortSignal.signal) {
                 fetchOptions.signal = abortSignal.signal;
             }
-            // Execute fetch
+            // Execute fetch (custom implementation if provided, global fetch otherwise)
+            const fetchFn = this._fetch ?? globalThis.fetch;
             let response;
             try {
-                response = await fetch(url, fetchOptions);
+                response = await fetchFn(url, fetchOptions);
             }
             catch (error) {
-                const errorObj = error instanceof Error ? error : new Error(String(error));
+                const errorObj = toError(error);
                 const errorName = errorObj.name;
-                const errorMessage = errorObj.message.toLowerCase();
+                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.requestOptions.timeout) {
-                        throw RequestError.timeout(url, method, this.requestOptions.timeout);
+                    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" || errorMessage.includes("timeout") || errorMessage.includes("aborted due to timeout");
-                if (isTimeoutError && this.requestOptions.timeout) {
-                    throw RequestError.timeout(url, method, this.requestOptions.timeout);
+                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)
@@ -2405,24 +2387,19 @@ class BaseRequest {
                 throw RequestError.networkError(url, method, new Error("Failed with status 0 (network error or CORS blocked)"));
             }
             if (!response.ok) {
-                throw RequestError.fromResponse(response, url, method);
+                // 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.getGraphQLOptions();
+            const graphQLOptions = this._gql();
             const wrappedResponse = new ResponseWrapper(response, url, method, graphQLOptions);
-            return await this.runResponseInterceptors(wrappedResponse);
+            return await this._runResI(wrappedResponse);
         }
         catch (error) {
             // Convert to RequestError if needed
-            let requestError;
-            if (error instanceof RequestError) {
-                requestError = error;
-            }
-            else {
-                const errorObj = error instanceof Error ? error : new Error(String(error));
-                requestError = RequestError.networkError(url, method, errorObj);
-            }
+            const requestError = error instanceof RequestError ? error : RequestError.networkError(url, method, toError(error));
             // Run error interceptors
-            const interceptorResult = await this.runErrorInterceptors(requestError);
+            const interceptorResult = await this._runErrI(requestError);
             // If error interceptor returned a ResponseWrapper, recover from error
             if (interceptorResult instanceof ResponseWrapper) {
                 return interceptorResult;
@@ -2439,12 +2416,9 @@ class BaseRequest {
  * Base class for requests that can have a body (POST, PUT, PATCH)
  */
 class BodyRequest extends BaseRequest {
-    body;
-    bodyType;
-    graphQLOptions = undefined;
-    constructor(url) {
-        super(url);
-    }
+    _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.
@@ -2481,11 +2455,11 @@ class BodyRequest extends BaseRequest {
      * ```
      */
     withBody(body) {
-        this.body = body;
+        this._body = body;
         // Set body type and validate
         if (typeof body === "string") {
-            this.bodyType = BodyType.STRING;
-            this.setContentTypeIfNeeded("text/plain");
+            this._bodyType = BodyType.STRING;
+            this._setCT("text/plain");
         }
         else if (body !== null &&
             typeof body === "object" &&
@@ -2496,18 +2470,18 @@ class BodyRequest extends BaseRequest {
                 ArrayBuffer.isView(body) || // Handles TypedArray and DataView
                 body instanceof URLSearchParams ||
                 body instanceof ReadableStream)) {
-            this.bodyType = BodyType.JSON;
-            this.setContentTypeIfNeeded("application/json");
+            this._bodyType = BodyType.JSON;
+            this._setCT("application/json");
             // Validate JSON is stringifiable early
             try {
                 JSON.stringify(body);
             }
             catch (error) {
-                throw new RequestError(`Bad JSON: ${error instanceof Error ? error.message : String(error)}`, this.url, this.method);
+                throw new RequestError(`Bad JSON: ${errorMessage(error)}`, this._url, this._method);
             }
         }
         else {
-            this.bodyType = BodyType.BINARY;
+            this._bodyType = BodyType.BINARY;
         }
         return this;
     }
@@ -2550,25 +2524,25 @@ class BodyRequest extends BaseRequest {
      */
     withGraphQL(query, variables, options) {
         if (typeof query !== "string" || query.length === 0) {
-            throw new RequestError("Bad query", this.url, this.method);
+            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);
+                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);
+                throw new RequestError("Bad opts", this._url, this._method);
             }
             // Store only the known GraphQL options properties
             const opts = options;
-            this.graphQLOptions = {
+            this._gqlOpts = {
                 throwOnError: typeof opts.throwOnError === "boolean" ? opts.throwOnError : undefined,
             };
         }
@@ -2577,26 +2551,26 @@ class BodyRequest extends BaseRequest {
             JSON.stringify(graphQLBody);
         }
         catch (error) {
-            throw new RequestError(`Bad JSON: ${error instanceof Error ? error.message : String(error)}`, this.url, this.method);
+            throw new RequestError(`Bad JSON: ${errorMessage(error)}`, this._url, this._method);
         }
-        this.body = graphQLBody;
-        this.bodyType = BodyType.JSON;
-        this.setContentTypeIfNeeded("application/json");
+        this._body = graphQLBody;
+        this._bodyType = BodyType.JSON;
+        this._setCT("application/json");
         return this;
     }
     /**
      * Check if Content-Type header is already set (case-insensitive)
      */
-    hasContentType() {
-        const headers = this.requestOptions.headers;
+    _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;
     }
-    setContentTypeIfNeeded(contentType) {
-        if (!this.hasContentType()) {
+    _setCT(contentType) {
+        if (!this._hasCT()) {
             this.withContentType(contentType);
         }
     }
@@ -2604,24 +2578,24 @@ class BodyRequest extends BaseRequest {
      * Get the GraphQL options if set
      * @returns The GraphQL options or undefined
      */
-    getGraphQLOptions() {
-        return this.graphQLOptions;
+    _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) {
+        if (this._body !== undefined) {
             // Remove previous body if it exists
-            if (this.requestOptions.body)
-                delete this.requestOptions.body;
+            if (this._opts.body)
+                delete this._opts.body;
             // Process the body based on its type
-            if (this.bodyType === BodyType.JSON) {
-                this.requestOptions.body = JSON.stringify(this.body);
+            if (this._bodyType === BodyType.JSON) {
+                this._opts.body = JSON.stringify(this._body);
             }
             else {
-                this.requestOptions.body = this.body;
+                this._opts.body = this._body;
             }
         }
         return super.getResponse();
@@ -2638,10 +2612,7 @@ class BodyRequest extends BaseRequest {
  * const data = await request.getData();
  */
 class GetRequest extends BaseRequest {
-    method = exports.HttpMethod.GET;
-    constructor(url) {
-        super(url);
-    }
+    _method = HttpMethod.GET;
 }
 /**
  * HTTP HEAD request implementation
@@ -2652,10 +2623,7 @@ class GetRequest extends BaseRequest {
  * const response = await request.getResponse();
  */
 class HeadRequest extends BaseRequest {
-    method = exports.HttpMethod.HEAD;
-    constructor(url) {
-        super(url);
-    }
+    _method = HttpMethod.HEAD;
 }
 /**
  * HTTP OPTIONS request implementation
@@ -2666,10 +2634,7 @@ class HeadRequest extends BaseRequest {
  * const response = await request.getResponse();
  */
 class OptionsRequest extends BaseRequest {
-    method = exports.HttpMethod.OPTIONS;
-    constructor(url) {
-        super(url);
-    }
+    _method = HttpMethod.OPTIONS;
 }
 /**
  * HTTP DELETE request implementation
@@ -2680,10 +2645,7 @@ class OptionsRequest extends BaseRequest {
  * await request.getData();
  */
 class DeleteRequest extends BaseRequest {
-    method = exports.HttpMethod.DELETE;
-    constructor(url) {
-        super(url);
-    }
+    _method = HttpMethod.DELETE;
 }
 /**
  * HTTP POST request implementation
@@ -2695,10 +2657,7 @@ class DeleteRequest extends BaseRequest {
  * const data = await request.getData();
  */
 class PostRequest extends BodyRequest {
-    method = exports.HttpMethod.POST;
-    constructor(url) {
-        super(url);
-    }
+    _method = HttpMethod.POST;
 }
 /**
  * HTTP PUT request implementation
@@ -2710,10 +2669,7 @@ class PostRequest extends BodyRequest {
  * const data = await request.getData();
  */
 class PutRequest extends BodyRequest {
-    method = exports.HttpMethod.PUT;
-    constructor(url) {
-        super(url);
-    }
+    _method = HttpMethod.PUT;
 }
 /**
  * HTTP PATCH request implementation
@@ -2725,10 +2681,7 @@ class PutRequest extends BodyRequest {
  * const data = await request.getData();
  */
 class PatchRequest extends BodyRequest {
-    method = exports.HttpMethod.PATCH;
-    constructor(url) {
-        super(url);
-    }
+    _method = HttpMethod.PATCH;
 }
 
 /**
@@ -2840,73 +2793,60 @@ function options(url) {
  * Internal API builder implementation.
  */
 class ApiBuilderImpl {
-    baseURL;
-    modifiers = [];
-    proxy;
+    _baseURL;
+    _mods = [];
+    _proxy;
     withBaseURL(baseURL) {
-        this.baseURL = baseURL;
-        return this.getProxy();
+        this._baseURL = baseURL;
+        return this._getProxy();
     }
-    resolveURL(url) {
+    _resolve(url) {
         if (!url)
-            return this.baseURL || "";
+            return this._baseURL || "";
         if (/^https?:\/\//.test(url))
             return url;
-        if (!this.baseURL)
+        if (!this._baseURL)
             return url;
-        return this.baseURL.replace(/\/$/, "") + (url[0] === "/" ? url : "/" + url);
+        return this._baseURL.replace(/\/$/, "") + (url[0] === "/" ? url : "/" + url);
     }
-    applyModifiers(request) {
-        if (this.modifiers)
-            for (const modifier of this.modifiers)
-                modifier(request);
+    _new(Ctor, url) {
+        const request = new Ctor(this._resolve(url));
+        for (const modifier of this._mods)
+            modifier(request);
+        return request;
     }
     get(url) {
-        const request = new GetRequest(this.resolveURL(url));
-        this.applyModifiers(request);
-        return request;
+        return this._new(GetRequest, url);
     }
     post(url) {
-        const request = new PostRequest(this.resolveURL(url));
-        this.applyModifiers(request);
-        return request;
+        return this._new(PostRequest, url);
     }
     put(url) {
-        const request = new PutRequest(this.resolveURL(url));
-        this.applyModifiers(request);
-        return request;
+        return this._new(PutRequest, url);
     }
     del(url) {
-        const request = new DeleteRequest(this.resolveURL(url));
-        this.applyModifiers(request);
-        return request;
+        return this._new(DeleteRequest, url);
     }
     patch(url) {
-        const request = new PatchRequest(this.resolveURL(url));
-        this.applyModifiers(request);
-        return request;
+        return this._new(PatchRequest, url);
     }
     head(url) {
-        const request = new HeadRequest(this.resolveURL(url));
-        this.applyModifiers(request);
-        return request;
+        return this._new(HeadRequest, url);
     }
     options(url) {
-        const request = new OptionsRequest(this.resolveURL(url));
-        this.applyModifiers(request);
-        return request;
+        return this._new(OptionsRequest, url);
     }
-    addModifier(modifier) {
-        this.modifiers.push(modifier);
-        return this.getProxy();
+    _add(modifier) {
+        this._mods.push(modifier);
+        return this._getProxy();
     }
-    getProxy() {
-        if (!this.proxy) {
-            this.proxy = this.createProxy();
+    _getProxy() {
+        if (!this._proxy) {
+            this._proxy = this._mkProxy();
         }
-        return this.proxy;
+        return this._proxy;
     }
-    createProxy() {
+    _mkProxy() {
         const disallowedMethods = new Set(["withBody", "withGraphQL", "withAbortController"]);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return new Proxy(this, {
@@ -2928,7 +2868,7 @@ class ApiBuilderImpl {
                 // 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.addModifier((request) => {
+                        return implTarget._add((request) => {
                             const method = request[prop];
                             if (typeof method === "function") {
                                 method.apply(request, args);
@@ -2943,7 +2883,7 @@ class ApiBuilderImpl {
         });
     }
     static create() {
-        return new ApiBuilderImpl().getProxy();
+        return new ApiBuilderImpl()._getProxy();
     }
 }
 /**
@@ -3024,16 +2964,24 @@ const create = {
     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;