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

package/dist/library/index.esm.js

@@ -1 +1,2097 @@
-var e,t,s,r,o,i,n,a,h;!function(e){e.GET="GET",e.PUT="PUT",e.POST="POST",e.HEAD="HEAD",e.PATCH="PATCH",e.DELETE="DELETE",e.OPTIONS="OPTIONS"}(e||(e={})),function(e){e.LOW="low",e.HIGH="high",e.AUTO="auto"}(t||(t={})),function(e){e.OMIT="omit",e.INCLUDE="include",e.SAME_ORIGIN="same-origin"}(s||(s={})),function(e){e.CORS="cors",e.NO_CORS="no-cors",e.SAME_ORIGIN="same-origin",e.NAVIGATE="navigate"}(r||(r={})),function(e){e.ERROR="error",e.FOLLOW="follow",e.MANUAL="manual"}(o||(o={})),function(e){e.DEFAULT="default",e.RELOAD="reload",e.NO_STORE="no-store",e.NO_CACHE="no-cache",e.FORCE_CACHE="force-cache",e.ONLY_IF_CACHED="only-if-cached"}(i||(i={})),function(e){e.LAX="Lax",e.NONE="None",e.STRICT="Strict"}(n||(n={})),function(e){e.JSON="json",e.STRING="string",e.BINARY="binary"}(a||(a={})),function(e){e.ORIGIN="origin",e.UNSAFE_URL="unsafe-url",e.SAME_ORIGIN="same-origin",e.NO_REFERRER="no-referrer",e.STRICT_ORIGIN="strict-origin",e.ORIGIN_WHEN_CROSS_ORIGIN="origin-when-cross-origin",e.NO_REFERRER_WHEN_DOWNGRADE="no-referrer-when-downgrade",e.STRICT_ORIGIN_WHEN_CROSS_ORIGIN="strict-origin-when-cross-origin"}(h||(h={}));class c{constructor(e){this.bodyUsed=!1,this.response=e}get status(){return this.response.status}get statusText(){return this.response.statusText}get headers(){return this.response.headers}get ok(){return this.response.ok}get raw(){return this.response}async getJson(){if(void 0!==this.jsonCache)return this.jsonCache;if(this.bodyUsed){if(void 0!==this.textCache)try{return this.jsonCache=JSON.parse(this.textCache),this.jsonCache}catch(e){throw Error("Cannot parse cached text as JSON")}throw Error("Response body has already been consumed in a different format")}return this.bodyUsed=!0,this.jsonCache=await this.response.json(),this.jsonCache}async getText(){if(void 0!==this.textCache)return this.textCache;if(this.bodyUsed){if(void 0!==this.jsonCache)return this.textCache=JSON.stringify(this.jsonCache),this.textCache;if(void 0!==this.blobCache)return this.textCache=await this.blobCache.text(),this.textCache;throw Error("Response body has already been consumed in a format that cannot be converted to text")}return this.bodyUsed=!0,this.textCache=await this.response.text(),this.textCache}async getBlob(){if(void 0!==this.blobCache)return this.blobCache;if(this.bodyUsed){if(void 0!==this.textCache)return this.blobCache=new Blob([this.textCache],{type:"text/plain"}),this.blobCache;throw Error("Response body has already been consumed in a format that cannot be converted to Blob")}return this.bodyUsed=!0,this.blobCache=await this.response.blob(),this.blobCache}async getArrayBuffer(){if(void 0!==this.arrayBufferCache)return this.arrayBufferCache;if(this.bodyUsed){if(void 0!==this.textCache){const e=(new TextEncoder).encode(this.textCache);return this.arrayBufferCache=e.buffer,this.arrayBufferCache}if(void 0!==this.blobCache)return this.arrayBufferCache=await this.blobCache.arrayBuffer(),this.arrayBufferCache;throw Error("Response body has already been consumed in a format that cannot be converted to ArrayBuffer")}return this.bodyUsed=!0,this.arrayBufferCache=await this.response.arrayBuffer(),this.arrayBufferCache}getBody(){if(this.bodyUsed)throw Error("Response body has already been consumed");return this.bodyUsed=!0,this.response.body}}function u(){const e=new Map;return{get:t=>e.get(t)||null,set(t,s){e.set(t,s)},has:t=>e.has(t),delete(t){e.delete(t)},clear(){e.clear()}}}function f(){return{get:e=>"undefined"==typeof localStorage?null:localStorage.getItem(e),set(e,t){if("undefined"!=typeof localStorage)try{localStorage.setItem(e,t)}catch(s){this.clear();try{localStorage.setItem(e,t)}catch(e){}}},has:e=>"undefined"!=typeof localStorage&&null!==localStorage.getItem(e),delete(e){"undefined"!=typeof localStorage&&localStorage.removeItem(e)},clear(){"undefined"!=typeof localStorage&&localStorage.clear()}}}function d(){return{get:e=>"undefined"==typeof sessionStorage?null:sessionStorage.getItem(e),set(e,t){if("undefined"!=typeof sessionStorage)try{sessionStorage.setItem(e,t)}catch(s){this.clear();try{sessionStorage.setItem(e,t)}catch(e){}}},has:e=>"undefined"!=typeof sessionStorage&&null!==sessionStorage.getItem(e),delete(e){"undefined"!=typeof sessionStorage&&sessionStorage.removeItem(e)},clear(){"undefined"!=typeof sessionStorage&&sessionStorage.clear()}}}class l{constructor(e={}){this.entryCount=0,this.totalSize=0,this.options=e,this.storage=function(e){const{storage:t}=e||{};return t?"function"==typeof t.get&&"function"==typeof t.set?t:t===localStorage?f():t===sessionStorage?d():t instanceof Map?{get:e=>t.get(e)||null,set(e,s,r){t.set(e,s)},has:e=>t.has(e),delete(e){t.delete(e)},clear(){t.clear()}}:u():u()}(e)}generateKey(e,t,s,r){if(this.options.keyGenerator){const o=this.options.keyGenerator(e,t,s,r);return this.options.keyPrefix?`${this.options.keyPrefix}:${o}`:o}let o=`${t}:${e}`;if(this.options.varyByHeaders&&s){const e={};this.options.varyByHeaders.forEach((t=>{const r=t.toLowerCase();Object.keys(s).forEach((t=>{t.toLowerCase()===r&&(e[r]=s[t])}))})),Object.keys(e).length>0&&(o+=":"+JSON.stringify(e))}if("GET"!==t&&null!=r)try{"string"==typeof r||"number"==typeof r||"boolean"==typeof r?o+=":"+r:"object"==typeof r&&(o+=":"+JSON.stringify(r))}catch(e){}return this.options.keyPrefix?`${this.options.keyPrefix}:${o}`:o}async get(e){const t=await Promise.resolve(this.storage.get(e));if(!t)return null;try{const s=JSON.parse(t);return s.expiry&&s.expiry<Date.now()?(await Promise.resolve(this.storage.delete(e)),null):s}catch(t){return await Promise.resolve(this.storage.delete(e)),null}}async set(e,t,s){const r=Date.now(),o=this.options.ttl,i=JSON.stringify({value:t,timestamp:r,expiry:o?r+o:null,headers:s});if(this.options.maxSize){const e=function(e){var t;if("number"==typeof e)return e;const s=e.match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB)?$/i);if(!s)return 0;const r=parseFloat(s[1]);switch(null===(t=s[2])||void 0===t?void 0:t.toUpperCase()){case"KB":return 1024*r;case"MB":return 1048576*r;case"GB":return 1073741824*r;default:return r}}(this.options.maxSize),t=(new TextEncoder).encode(i).length;if(t>e)return;this.totalSize+t>e&&(await Promise.resolve(this.storage.clear()),this.totalSize=0,this.entryCount=0),this.totalSize+=t}this.options.maxEntries&&(this.entryCount++,this.entryCount>this.options.maxEntries&&(await Promise.resolve(this.storage.clear()),this.entryCount=1)),await Promise.resolve(this.storage.set(e,i,o))}async has(e){return Promise.resolve(this.storage.has(e))}async delete(e){return Promise.resolve(this.storage.delete(e))}async clear(){return this.entryCount=0,this.totalSize=0,Promise.resolve(this.storage.clear())}}class y{static formatRequestCookies(e){const t=[];return Object.entries(e).forEach((([e,s])=>{let r;r="string"==typeof s?s:s.value,t.push(`${encodeURIComponent(e)}=${encodeURIComponent(r)}`)})),t.join("; ")}}class p extends Error{constructor(e,t,s,r={}){super(e),this.name="RequestError",this.url=t,this.method=s,this.status=r.status,this.response=r.response,this.timeoutError=r.timeoutError,Error.captureStackTrace&&Error.captureStackTrace(this,p),Object.setPrototypeOf(this,p.prototype)}static timeout(e,t,s){return new p(`Request timed out after ${s}ms`,e,t,{timeoutError:!0})}static fromResponse(e,t,s){return new p("Request failed with status "+e.status,t,s,{status:e.status,response:e})}static networkError(e,t,s){const r=new p("Network error: "+s.message,e,t);return r.stack=s.stack,r}}class m{static getTokenFromMeta(e="csrf-token"){if("undefined"==typeof document)return null;const t=document.querySelector(`meta[name="${e}"]`);return(null==t?void 0:t.getAttribute("content"))||null}static getTokenFromCookie(e="csrf-token"){if("undefined"==typeof document)return null;const t=document.cookie.split(";");for(const s of t){const[t,r]=s.trim().split("=");if(t===e)return decodeURIComponent(r)}return null}static isValidToken(e){return!("string"!=typeof e||8>e.length||e.length>10&&(!/^[A-Za-z0-9\-_=+/.]+$/.test(e)||2>[/[A-Z]/.test(e),/[a-z]/.test(e),/[0-9]/.test(e),/[-_=+/.]/.test(e)].filter(Boolean).length))}}class g{constructor(){this.csrfHeaderName="X-CSRF-Token",this.xsrfCookieName="XSRF-TOKEN",this.xsrfHeaderName="X-XSRF-TOKEN",this.csrfToken=null,this.enableAutoXsrf=!0,this.enableAntiCsrf=!0}static getInstance(){return g.instance||(g.instance=new g),g.instance}setCsrfToken(e){return this.csrfToken=e,this}getCsrfToken(){return this.csrfToken}setCsrfHeaderName(e){return this.csrfHeaderName=e,this}getCsrfHeaderName(){return this.csrfHeaderName}setXsrfCookieName(e){return this.xsrfCookieName=e,this}getXsrfCookieName(){return this.xsrfCookieName}setXsrfHeaderName(e){return this.xsrfHeaderName=e,this}getXsrfHeaderName(){return this.xsrfHeaderName}setEnableAutoXsrf(e){return this.enableAutoXsrf=e,this}isAutoXsrfEnabled(){return this.enableAutoXsrf}setEnableAntiCsrf(e){return this.enableAntiCsrf=e,this}isAntiCsrfEnabled(){return this.enableAntiCsrf}reset(){return this.csrfToken=null,this.csrfHeaderName="X-CSRF-Token",this.enableAntiCsrf=!0,this.xsrfCookieName="XSRF-TOKEN",this.xsrfHeaderName="X-XSRF-TOKEN",this.enableAutoXsrf=!0,this}}class C{constructor(){this.requestOptions={headers:{}},this.queryParams=new URLSearchParams,this.autoApplyCsrfProtection=!0,this.cacheEnabled=!1}withHeaders(e){return this.requestOptions.headers={...this.requestOptions.headers,...e},this}withHeader(e,t){return this.withHeaders({[e]:t})}withTimeout(e){if(!Number.isFinite(e)||0>=e)throw Error("Timeout must be a positive number");return this.requestOptions.timeout=e,this}withRetries(e){if(!Number.isInteger(e)||0>e)throw Error("Retry count must be a non-negative integer");return this.requestOptions.retries=e,this}onRetry(e){return this.requestOptions.onRetry=e,this}withCredentials(e=s.SAME_ORIGIN){return this.requestOptions.credentials=e,this}withAbortController(e){return this.abortController=e,this}withReferrer(e){return this.requestOptions.referrer=e,this}withReferrerPolicy(e){return this.requestOptions.referrerPolicy=e,this}withRedirect(e){return this.requestOptions.redirect=e,this}withKeepAlive(e){return this.requestOptions.keepalive=e,this}withPriority(e){return this.requestOptions.priority=e,this}withQueryParams(e){return Object.entries(e).forEach((([e,t])=>{null!=t&&(Array.isArray(t)?t.forEach((t=>this.queryParams.append(e,t+""))):this.queryParams.append(e,t+""))})),this}withQueryParam(e,t){return null==t||(Array.isArray(t)?t.forEach((t=>this.queryParams.append(e,t+""))):this.queryParams.append(e,t+"")),this}withMode(e){return this.requestOptions.mode=e,this}withContentType(e){return this.withHeaders({"Content-Type":e})}withAuthorization(e){return this.withHeaders({Authorization:e})}withBasicAuth(e,t){const s=this.encodeBase64(`${e}:${t}`);return this.withAuthorization("Basic "+s)}encodeBase64(e){if("undefined"!=typeof TextEncoder&&"function"==typeof btoa){const t=(new TextEncoder).encode(e);return btoa(String.fromCharCode.call(null,...new Uint8Array(t)))}if("function"==typeof btoa)return btoa(e);if("undefined"!=typeof Buffer)return Buffer.from(e).toString("base64");throw Error("Base64 encoding is not supported")}withBearerToken(e){return this.withAuthorization("Bearer "+e)}hasHeader(e,t){return Object.keys(e).some((e=>e.toLowerCase()===t.toLowerCase()))}withCookies(e){if(0===Object.entries(e||{}).length)return this;const t=this.requestOptions.headers||{},s=[],r=[];Object.keys(t).forEach((e=>{"cookie"===e.toLowerCase()&&(t[e]&&s.push(t[e]),r.push(e))}));const o=y.formatRequestCookies(e),i=r.length>0?r[0]:"Cookie",n=[...s,o].filter(Boolean).join("; "),a={...t};return r.forEach((e=>{delete a[e]})),this.requestOptions.headers={...a,[i]:n},this}withCookie(e,t){return this.withCookies({[e]:t})}withCsrfToken(e,t="X-CSRF-Token"){return this.withHeaders({[t]:e})}withoutCsrfProtection(){return this.autoApplyCsrfProtection=!1,this}withAntiCsrfHeaders(){return this.withHeaders({"X-Requested-With":"XMLHttpRequest"})}withCache(e={}){return this.cacheEnabled=!0,this.cacheManager=new l(e),this}sendTo(e){if(e=this.formatUrlWithQueryParams(e),this.autoApplyCsrfProtection){const e=g.getInstance();e.isAntiCsrfEnabled()&&this.withHeaders({"X-Requested-With":"XMLHttpRequest"});const t=e.getCsrfToken();if(t){const s=this.requestOptions.headers,r=e.getCsrfHeaderName();this.hasHeader(s,"X-CSRF-Token")||this.hasHeader(s,r)||this.withHeaders({[r]:t})}if(e.isAutoXsrfEnabled()&&"undefined"!=typeof document){const t=m.getTokenFromCookie(e.getXsrfCookieName());if(t&&m.isValidToken(t)){const s=this.requestOptions.headers,r=e.getXsrfHeaderName();this.hasHeader(s,"X-XSRF-TOKEN")||this.hasHeader(s,r)||this.withHeaders({[r]:t})}}}const t={...this.requestOptions,method:this.method};let s;if(this.cacheEnabled&&this.cacheManager){const r=this.cacheManager.generateKey(e,this.method,this.requestOptions.headers,this.requestOptions.body);s=this.executeWithCache(e,t,r)}else s=this.requestOptions.retries?this.executeWithRetries(e,t):this.executeRequest(e,t);const r=s;return r.getJson=async()=>s.then((e=>e.getJson())),r.getText=async()=>s.then((e=>e.getText())),r.getBlob=async()=>s.then((e=>e.getBlob())),r.getArrayBuffer=async()=>s.then((e=>e.getArrayBuffer())),r.getBody=async()=>s.then((e=>e.getBody())),r.getData=async e=>{try{const t=await s.then((e=>e.getJson()));return e?e(t):t}catch(e){const t=Error(`Data selector failed: ${e instanceof Error?e.message:e+""}. Original data: ${JSON.stringify(await s.then((e=>e.getJson())),null,2)}`);throw e instanceof Error&&e.stack&&(t.stack=e.stack),t}},r}formatUrlWithQueryParams(e){if(!(""+this.queryParams))return e;try{const t=new URL(e);return this.queryParams.forEach(((e,s)=>{t.searchParams.append(s,e)})),""+t}catch(t){const s=e.includes("?");return`${e}${s?"&":"?"}${""+this.queryParams}`}}async executeWithRetries(e,t){const s=this.requestOptions.retries||0;for(let r=0;s>=r;r++)try{return await this.executeRequest(e,t)}catch(o){const i=o instanceof p?o:p.networkError(e,t.method,o);if(r>=s)throw i;this.requestOptions.onRetry&&await this.requestOptions.onRetry({attempt:r+1,error:i})}throw new p("Max retries reached",e,t.method)}async executeRequest(e,t){const s=this.abortController||new AbortController,{signal:r}=s;let o;t.signal=t.signal||r;let i=!1;this.requestOptions.timeout&&(this.abortController?"function"==typeof AbortSignal.timeout?AbortSignal.timeout(this.requestOptions.timeout).addEventListener("abort",(()=>{s.signal.aborted||(i=!0,s.abort())})):o=setTimeout((()=>{s.signal.aborted||(i=!0,s.abort())}),this.requestOptions.timeout):o=setTimeout((()=>{i=!0,s.abort()}),this.requestOptions.timeout));try{let s;try{s=await fetch(e,t)}catch(s){if(s instanceof DOMException&&"AbortError"===s.name&&i)throw p.timeout(e,t.method,this.requestOptions.timeout);throw p.networkError(e,t.method,s)}if(!s.ok)throw p.fromResponse(s,e,t.method);return new c(s)}finally{o&&clearTimeout(o)}}async executeWithCache(e,t,s){if(this.cacheManager){const e=await this.cacheManager.get(s);if(e){const t=new Response(JSON.stringify(e.value),{status:200,headers:new Headers(e.headers||{})});return new c(t)}}const r=await(this.requestOptions.retries?this.executeWithRetries(e,t):this.executeRequest(e,t));if(r.ok&&this.cacheManager)try{const e=await r.getJson(),t={};r.headers.forEach(((e,s)=>{t[s]=e})),await this.cacheManager.set(s,e,t)}catch(e){}return r}}class b extends C{withBody(e){if(this.body=e,"string"==typeof e)this.bodyType=a.STRING,this.setContentTypeIfNeeded("text/plain");else if(null===e||"object"!=typeof e||e instanceof FormData||e instanceof Blob||e instanceof ArrayBuffer||e instanceof URLSearchParams||e instanceof ReadableStream)this.bodyType=a.BINARY;else{this.bodyType=a.JSON,this.setContentTypeIfNeeded("application/json");try{JSON.stringify(e)}catch(e){throw Error("Failed to stringify request body: "+e)}}return this}setContentTypeIfNeeded(e){Object.keys(this.requestOptions.headers).some((e=>"content-type"===e.toLowerCase()))||this.withContentType(e)}sendTo(e){return void 0!==this.body&&(this.requestOptions.body&&delete this.requestOptions.body,this.requestOptions.body=this.bodyType===a.JSON?JSON.stringify(this.body):this.body),super.sendTo(e)}}class w extends C{constructor(){super(...arguments),this.method=e.GET}}class O extends C{constructor(){super(...arguments),this.method=e.HEAD}}class E extends C{constructor(){super(...arguments),this.method=e.OPTIONS}}class S extends C{constructor(){super(...arguments),this.method=e.DELETE}}class R extends b{constructor(){super(...arguments),this.method=e.POST}}class T extends b{constructor(){super(...arguments),this.method=e.PUT}}class N extends b{constructor(){super(...arguments),this.method=e.PATCH}}const x={get:function(){return new w},post:function(){return new R},put:function(){return new T},del:function(){return new S},patch:function(){return new N},head:function(){return new O},options:function(){return new E},config:g.getInstance()};export{l as CacheManager,i as CacheMode,y as CookieUtils,s as CredentialsPolicy,S as DeleteRequest,w as GetRequest,O as HeadRequest,e as HttpMethod,E as OptionsRequest,N as PatchRequest,R as PostRequest,T as PutRequest,o as RedirectMode,h as ReferrerPolicy,p as RequestError,r as RequestMode,t as RequestPriority,c as ResponseWrapper,n as SameSitePolicy,f as createLocalStorageStorage,u as createMemoryStorage,d as createSessionStorageStorage,x as default};//# sourceMappingURL=index.esm.js.map
+/**
+ * Enum for HTTP methods
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+})(HttpMethod || (HttpMethod = {}));
+/**
+ * Enum for request priorities
+ */
+var RequestPriority;
+(function (RequestPriority) {
+    RequestPriority["LOW"] = "low";
+    RequestPriority["HIGH"] = "high";
+    RequestPriority["AUTO"] = "auto";
+})(RequestPriority || (RequestPriority = {}));
+/**
+ * Enum for credentials policies
+ */
+var CredentialsPolicy;
+(function (CredentialsPolicy) {
+    CredentialsPolicy["OMIT"] = "omit";
+    CredentialsPolicy["INCLUDE"] = "include";
+    CredentialsPolicy["SAME_ORIGIN"] = "same-origin";
+})(CredentialsPolicy || (CredentialsPolicy = {}));
+/**
+ * Enum for request modes
+ */
+var RequestMode;
+(function (RequestMode) {
+    RequestMode["CORS"] = "cors";
+    RequestMode["NO_CORS"] = "no-cors";
+    RequestMode["SAME_ORIGIN"] = "same-origin";
+    RequestMode["NAVIGATE"] = "navigate";
+})(RequestMode || (RequestMode = {}));
+/**
+ * Enum for redirect modes
+ */
+var RedirectMode;
+(function (RedirectMode) {
+    RedirectMode["ERROR"] = "error";
+    RedirectMode["FOLLOW"] = "follow";
+    RedirectMode["MANUAL"] = "manual";
+})(RedirectMode || (RedirectMode = {}));
+/**
+ * Enum for cookie SameSite policies
+ */
+var SameSitePolicy;
+(function (SameSitePolicy) {
+    SameSitePolicy["LAX"] = "Lax";
+    SameSitePolicy["NONE"] = "None";
+    SameSitePolicy["STRICT"] = "Strict";
+})(SameSitePolicy || (SameSitePolicy = {}));
+/**
+ * Enum for body types
+ */
+var BodyType;
+(function (BodyType) {
+    BodyType["JSON"] = "json";
+    BodyType["STRING"] = "string";
+    BodyType["BINARY"] = "binary";
+})(BodyType || (BodyType = {}));
+/**
+ * Referrer policies for fetch requests
+ */
+var ReferrerPolicy;
+(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";
+})(ReferrerPolicy || (ReferrerPolicy = {}));
+
+class RequestError extends Error {
+    constructor(message, url, method, options = {}) {
+        super(message);
+        this.name = "RequestError";
+        this.url = url;
+        this.method = method;
+        this.status = options.status;
+        this.response = options.response;
+        this.isTimeout = options.isTimeout;
+        this.isAborted = options.isAborted;
+        // For better stack traces in modern environments
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, RequestError);
+        }
+        // Maintains proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, RequestError.prototype);
+    }
+    /**
+     * Static methods for creating specific types of RequestError
+     */
+    static timeout(url, method, timeoutMs) {
+        return new RequestError(`Timeout: ${timeoutMs}ms`, url, method, {
+            isTimeout: true,
+        });
+    }
+    static fromResponse(response, url, method) {
+        return new RequestError(`HTTP ${response.status}`, url, method, {
+            status: response.status,
+            response,
+        });
+    }
+    static networkError(url, method, originalError) {
+        // Provide more descriptive error messages for common network errors
+        let message = originalError.message;
+        // Check for Node.js error codes (e.g., from undici/dns errors)
+        const errorCode = originalError.code;
+        const errorName = originalError.name;
+        const stack = originalError.stack || "";
+        const errorMessageLower = message.toLowerCase();
+        // Check for timeout errors (Node.js/undici TimeoutError)
+        const isTimeoutError = errorName === "TimeoutError" ||
+            errorMessageLower.includes("timeout") ||
+            errorMessageLower.includes("aborted due to timeout") ||
+            errorCode === "ETIMEDOUT" ||
+            stack.includes("TimeoutError") ||
+            stack.includes("timeout");
+        // If the error message is generic "fetch failed", provide more context
+        if (message === "fetch failed" || message === "Failed to fetch") {
+            // Check for DNS resolution errors
+            const isDnsError = errorCode === "ENOTFOUND" ||
+                errorCode === "EAI_AGAIN" ||
+                errorCode === "EAI_NODATA" ||
+                stack.includes("getaddrinfo") ||
+                stack.includes("ENOTFOUND") ||
+                stack.includes("EAI_AGAIN");
+            // Check for connection errors (but not timeout errors)
+            const isConnectionError = !isTimeoutError && (errorCode === "ECONNREFUSED" || errorCode === "ECONNRESET" || stack.includes("ECONNREFUSED") || stack.includes("connect"));
+            if (isTimeoutError) {
+                message = `Network error: Request timeout for ${url}`;
+            }
+            else if (isDnsError) {
+                message = `Network error: Unable to resolve hostname for ${url}`;
+            }
+            else if (isConnectionError) {
+                message = `Network error: Connection refused for ${url}`;
+            }
+            else {
+                message = `Network error: Failed to fetch ${url}`;
+            }
+        }
+        const error = new RequestError(message, url, method, {
+            ...(isTimeoutError ? { isTimeout: true } : {}),
+        });
+        // Create a proper RequestError stack trace, but append the original stack for debugging
+        // This way Node.js will show "RequestError: ..." instead of "TypeError: ..."
+        if (originalError.stack) {
+            // Get the current stack (which will start with RequestError)
+            const currentStack = error.stack || "";
+            // Append the original error's stack as "Caused by:" for debugging context
+            error.stack = `${currentStack}\n\nCaused by: ${originalError.stack}`;
+        }
+        return error;
+    }
+    static abortError(url, method) {
+        return new RequestError("Aborted", url, method, {
+            isAborted: true,
+        });
+    }
+}
+
+/**
+ * Wrapper for HTTP responses with methods to transform the response data
+ * Provides caching and conversion between different response formats.
+ */
+class ResponseWrapper {
+    constructor(response, url, method) {
+        this.bodyUsed = false;
+        this.response = response;
+        this.url = url;
+        this.method = method;
+    }
+    // Wrapper properties
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get ok() {
+        return this.response.ok;
+    }
+    get raw() {
+        return this.response;
+    }
+    /**
+     * Parse the response body as JSON
+     * Caches the result for subsequent calls.
+     *
+     * @returns The parsed JSON data
+     * @throws Error if the response has already been consumed in a different format
+     *
+     * @example
+     * const data = await response.getJson();
+     * console.log(data.items);
+     */
+    async getJson() {
+        if (this.jsonCache !== undefined) {
+            return this.jsonCache;
+        }
+        if (this.bodyUsed) {
+            // If we already have text, try to parse it as JSON
+            if (this.textCache !== undefined) {
+                try {
+                    const parsed = JSON.parse(this.textCache);
+                    this.jsonCache = parsed;
+                    return parsed;
+                }
+                catch (e) {
+                    const errorMessage = e instanceof Error ? e.message : String(e);
+                    if (this.url && this.method) {
+                        throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url, this.method, {
+                            response: this.response,
+                        });
+                    }
+                    throw new Error(`Invalid JSON: ${errorMessage}`);
+                }
+            }
+            if (this.url && this.method) {
+                throw new RequestError("Body already consumed", this.url, this.method, {
+                    response: this.response,
+                });
+            }
+            throw new Error("Body already consumed");
+        }
+        this.bodyUsed = true;
+        try {
+            const parsed = await this.response.json();
+            this.jsonCache = parsed;
+            return parsed;
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            if (this.url && this.method) {
+                throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url, this.method, {
+                    status: this.response.status,
+                    response: this.response,
+                });
+            }
+            throw e;
+        }
+    }
+    /**
+     * Get the response body as text
+     * Caches the result for subsequent calls. Attempts to convert from JSON or Blob
+     * if the body has already been consumed in those formats.
+     *
+     * @returns The response text
+     * @throws Error if the response has already been consumed in an incompatible format
+     *
+     * @example
+     * const text = await response.getText();
+     */
+    async getText() {
+        if (this.textCache !== undefined) {
+            return this.textCache;
+        }
+        if (this.bodyUsed) {
+            // If we already have JSON, convert it to text
+            if (this.jsonCache !== undefined) {
+                this.textCache = JSON.stringify(this.jsonCache);
+                return this.textCache;
+            }
+            // If we have blob, convert to text
+            if (this.blobCache !== undefined) {
+                try {
+                    this.textCache = await this.blobCache.text();
+                    return this.textCache;
+                }
+                catch (e) {
+                    const errorMessage = e instanceof Error ? e.message : String(e);
+                    if (this.url && this.method) {
+                        throw new RequestError(`Cannot convert to text: ${errorMessage}`, this.url, this.method, {
+                            response: this.response,
+                        });
+                    }
+                    throw e;
+                }
+            }
+            if (this.url && this.method) {
+                throw new RequestError("Cannot convert to text", this.url, this.method, {
+                    response: this.response,
+                });
+            }
+            throw new Error("Cannot convert to text");
+        }
+        this.bodyUsed = true;
+        try {
+            this.textCache = await this.response.text();
+            return this.textCache;
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            if (this.url && this.method) {
+                throw new RequestError(`Read failed: ${errorMessage}`, this.url, this.method, {
+                    status: this.response.status,
+                    response: this.response,
+                });
+            }
+            throw e;
+        }
+    }
+    /**
+     * Get the response body as a Blob
+     * Caches the result for subsequent calls. Attempts to convert from text
+     * if the body has already been consumed as text.
+     *
+     * @returns The response as a Blob
+     * @throws Error if the response has already been consumed in an incompatible format
+     *
+     * @example
+     * const blob = await response.getBlob();
+     * const url = URL.createObjectURL(blob);
+     */
+    async getBlob() {
+        if (this.blobCache !== undefined) {
+            return this.blobCache;
+        }
+        if (this.bodyUsed) {
+            // If we have text, convert to Blob
+            if (this.textCache !== undefined) {
+                this.blobCache = new Blob([this.textCache], { type: "text/plain" });
+                return this.blobCache;
+            }
+            if (this.url && this.method) {
+                throw new RequestError("Cannot convert to Blob", this.url, this.method, {
+                    response: this.response,
+                });
+            }
+            throw new Error("Cannot convert to Blob");
+        }
+        this.bodyUsed = true;
+        try {
+            this.blobCache = await this.response.blob();
+            return this.blobCache;
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            if (this.url && this.method) {
+                throw new RequestError(`Read failed: ${errorMessage}`, this.url, this.method, {
+                    status: this.response.status,
+                    response: this.response,
+                });
+            }
+            throw e;
+        }
+    }
+    /**
+     * Get the raw response body as a ReadableStream
+     * This method consumes the body and should only be called once.
+     *
+     * @returns The response body as a ReadableStream or null
+     * @throws Error if the response body has already been consumed
+     *
+     * @example
+     * const stream = response.getBody();
+     * if (stream) {
+     *   const reader = stream.getReader();
+     *   // Process the stream
+     * }
+     */
+    getBody() {
+        if (this.bodyUsed) {
+            if (this.url && this.method) {
+                throw new RequestError("Body already consumed", this.url, this.method, {
+                    response: this.response,
+                });
+            }
+            throw new Error("Body already consumed");
+        }
+        this.bodyUsed = true;
+        return this.response.body;
+    }
+    /**
+     * Extract specific data using a selector function
+     * If no selector is provided, returns the full JSON response.
+     *
+     * @param selector - Optional function to extract and transform data
+     * @returns A promise that resolves to the selected data
+     *
+     * @example
+     * // Get full response
+     * const data = await response.getData();
+     *
+     * // Extract specific data
+     * const users = await response.getData(data => data.results.users);
+     */
+    async getData(selector) {
+        try {
+            const data = await this.getJson();
+            // If no selector is provided, return the raw JSON data
+            if (!selector)
+                return data;
+            // Apply the selector if provided
+            return selector(data);
+        }
+        catch (error) {
+            // If it's already a RequestError, re-throw it
+            if (error instanceof RequestError) {
+                throw error;
+            }
+            // Enhance selector errors with context
+            if (selector) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (this.url && this.method) {
+                    throw new RequestError(`Data selector failed: ${errorMessage}`, this.url, this.method, {
+                        response: this.response,
+                    });
+                }
+                throw new Error(`Data selector failed: ${errorMessage}`);
+            }
+            // If we get here and it's not a RequestError, wrap it
+            // This should rarely happen as getJson() should throw RequestError
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            if (this.url && this.method) {
+                throw RequestError.networkError(this.url, this.method, errorObj);
+            }
+            throw errorObj;
+        }
+    }
+}
+
+class CookieUtils {
+    /**
+     * Formats cookies for a request
+     * @param cookies Object containing cookie name-value pairs or cookie options
+     * @returns Formatted cookie string for the Cookie header
+     */
+    static formatRequestCookies(cookies) {
+        const cookiePairs = [];
+        Object.entries(cookies).forEach(([name, valueOrOptions]) => {
+            let value;
+            if (typeof valueOrOptions === "string") {
+                value = valueOrOptions;
+            }
+            else {
+                // Extract value from options object without validation
+                value = valueOrOptions.value;
+            }
+            // Add the cookie to the request
+            cookiePairs.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
+        });
+        return cookiePairs.join("; ");
+    }
+}
+
+/**
+ * Utility class for CSRF token management
+ */
+class CsrfUtils {
+    /**
+     * Extracts CSRF token from a meta tag in the document head
+     * @param metaName The name attribute of the meta tag (default: "csrf-token")
+     * @returns The CSRF token or null if not found
+     */
+    static getTokenFromMeta(metaName = "csrf-token") {
+        if (typeof document === "undefined") {
+            return null;
+        }
+        const meta = document.querySelector(`meta[name="${metaName}"]`);
+        return (meta === null || meta === void 0 ? void 0 : meta.getAttribute("content")) || null;
+    }
+    /**
+     * Extracts CSRF token from a cookie
+     * @param cookieName The name of the cookie containing the CSRF token
+     * @returns The CSRF token or null if not found
+     */
+    static getTokenFromCookie(cookieName = "csrf-token") {
+        if (typeof document === "undefined") {
+            return null;
+        }
+        const cookies = document.cookie.split(";");
+        for (const cookie of cookies) {
+            const [name, value] = cookie.trim().split("=");
+            if (name === cookieName) {
+                return decodeURIComponent(value);
+            }
+        }
+        return null;
+    }
+    /**
+     * Validates if the provided string is a potential CSRF token
+     * Checks if the token meets security requirements
+     * @param token The token to validate
+     * @returns Whether the token is valid
+     */
+    static isValidToken(token) {
+        // Basic checks for null/undefined and type
+        if (typeof token !== "string") {
+            return false;
+        }
+        if (token.length < 8)
+            return false;
+        // If token is longer than 10 chars, perform additional security checks
+        if (token.length > 10) {
+            // Check for valid character set (alphanumeric & common token symbols)
+            const validTokenRegex = /^[A-Za-z0-9\-_=+/.]+$/;
+            if (!validTokenRegex.test(token)) {
+                return false;
+            }
+            // For longer tokens, check for sufficient entropy (at least 2 character types)
+            const hasUpperCase = /[A-Z]/.test(token);
+            const hasLowerCase = /[a-z]/.test(token);
+            const hasNumbers = /[0-9]/.test(token);
+            const hasSpecials = /[-_=+/.]/.test(token);
+            const characterTypesCount = [hasUpperCase, hasLowerCase, hasNumbers, hasSpecials].filter(Boolean).length;
+            return characterTypesCount >= 2;
+        }
+        // For shorter tokens (8-10 chars), just return true if we reached here
+        return true;
+    }
+}
+
+/**
+ * Global configuration for create-request
+ */
+class Config {
+    constructor() {
+        // CSRF configuration
+        this.csrfHeaderName = "X-CSRF-Token";
+        this.xsrfCookieName = "XSRF-TOKEN";
+        this.xsrfHeaderName = "X-XSRF-TOKEN";
+        this.csrfToken = null;
+        this.enableAutoXsrf = true;
+        this.enableAntiCsrf = true; // X-Requested-With header
+        // Interceptor configuration
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.errorInterceptors = [];
+        this.nextInterceptorId = 1;
+    }
+    /**
+     * Get the singleton instance of the Config class
+     *
+     * @returns The global configuration instance
+     *
+     * @example
+     * const config = Config.getInstance();
+     * config.setCsrfToken('token123');
+     */
+    static getInstance() {
+        if (!Config.instance) {
+            Config.instance = new Config();
+        }
+        return Config.instance;
+    }
+    /**
+     * Set a global CSRF token to be used for all requests
+     *
+     * @param token - The CSRF token value
+     * @returns The config instance for chaining
+     *
+     * @example
+     * Config.getInstance().setCsrfToken('myToken123');
+     */
+    setCsrfToken(token) {
+        this.csrfToken = token;
+        return this;
+    }
+    /**
+     * Get the global CSRF token that will be automatically applied to requests
+     *
+     * @returns The current CSRF token or null if not set
+     */
+    getCsrfToken() {
+        return this.csrfToken;
+    }
+    /**
+     * Set the CSRF header name used when sending the token
+     *
+     * @param name - The header name to use
+     * @returns The config instance for chaining
+     *
+     * @example
+     * Config.getInstance().setCsrfHeaderName('X-My-CSRF-Token');
+     */
+    setCsrfHeaderName(name) {
+        this.csrfHeaderName = name;
+        return this;
+    }
+    /**
+     * Get the configured CSRF header name
+     *
+     * @returns The current CSRF header name
+     */
+    getCsrfHeaderName() {
+        return this.csrfHeaderName;
+    }
+    /**
+     * Set the XSRF cookie name to look for when extracting tokens from cookies
+     *
+     * @param name - The cookie name to look for
+     * @returns The config instance for chaining
+     *
+     * @example
+     * Config.getInstance().setXsrfCookieName('MY-XSRF-COOKIE');
+     */
+    setXsrfCookieName(name) {
+        this.xsrfCookieName = name;
+        return this;
+    }
+    /**
+     * Get the configured XSRF cookie name
+     *
+     * @returns The current XSRF cookie name
+     */
+    getXsrfCookieName() {
+        return this.xsrfCookieName;
+    }
+    /**
+     * Set the XSRF header name for sending tokens extracted from cookies
+     *
+     * @param name - The header name to use
+     * @returns The config instance for chaining
+     */
+    setXsrfHeaderName(name) {
+        this.xsrfHeaderName = name;
+        return this;
+    }
+    /**
+     * Get the configured XSRF header name
+     *
+     * @returns The current XSRF header name
+     */
+    getXsrfHeaderName() {
+        return this.xsrfHeaderName;
+    }
+    /**
+     * Enable or disable automatic extraction of XSRF tokens from cookies
+     * When enabled, the library will look for XSRF tokens in cookies and
+     * automatically add them to request headers.
+     *
+     * @param enable - Whether to enable this feature
+     * @returns The config instance for chaining
+     *
+     * @example
+     * Config.getInstance().setEnableAutoXsrf(false); // Disable XSRF extraction
+     */
+    setEnableAutoXsrf(enable) {
+        this.enableAutoXsrf = enable;
+        return this;
+    }
+    /**
+     * Check if automatic XSRF token extraction is enabled
+     *
+     * @returns True if automatic XSRF is enabled
+     */
+    isAutoXsrfEnabled() {
+        return this.enableAutoXsrf;
+    }
+    /**
+     * Enable or disable automatic addition of anti-CSRF headers
+     * When enabled, X-Requested-With: XMLHttpRequest will be added to all requests.
+     *
+     * @param enable - Whether to enable this feature
+     * @returns The config instance for chaining
+     */
+    setEnableAntiCsrf(enable) {
+        this.enableAntiCsrf = enable;
+        return this;
+    }
+    /**
+     * Check if anti-CSRF protection is enabled
+     *
+     * @returns True if anti-CSRF protection is enabled
+     */
+    isAntiCsrfEnabled() {
+        return this.enableAntiCsrf;
+    }
+    /**
+     * Add a global request interceptor
+     * Request interceptors can modify the request configuration or return an early response
+     *
+     * @param interceptor - The request interceptor function
+     * @returns The interceptor ID for later removal
+     *
+     * @example
+     * const id = Config.getInstance().addRequestInterceptor((config) => {
+     *   config.headers['X-Custom'] = 'value';
+     *   return config;
+     * });
+     */
+    addRequestInterceptor(interceptor) {
+        const id = this.nextInterceptorId++;
+        this.requestInterceptors.push({ id, interceptor });
+        return id;
+    }
+    /**
+     * Add a global response interceptor
+     * Response interceptors can transform the response
+     *
+     * @param interceptor - The response interceptor function
+     * @returns The interceptor ID for later removal
+     *
+     * @example
+     * const id = Config.getInstance().addResponseInterceptor((response) => {
+     *   console.log('Response received:', response.status);
+     *   return response;
+     * });
+     */
+    addResponseInterceptor(interceptor) {
+        const id = this.nextInterceptorId++;
+        this.responseInterceptors.push({ id, interceptor });
+        return id;
+    }
+    /**
+     * Add a global error interceptor
+     * Error interceptors can handle or transform errors
+     *
+     * @param interceptor - The error interceptor function
+     * @returns The interceptor ID for later removal
+     *
+     * @example
+     * const id = Config.getInstance().addErrorInterceptor((error) => {
+     *   console.error('Request failed:', error);
+     *   throw error;
+     * });
+     */
+    addErrorInterceptor(interceptor) {
+        const id = this.nextInterceptorId++;
+        this.errorInterceptors.push({ id, interceptor });
+        return id;
+    }
+    /**
+     * Remove a request interceptor by its ID
+     *
+     * @param id - The interceptor ID returned from addRequestInterceptor
+     *
+     * @example
+     * Config.getInstance().removeRequestInterceptor(id);
+     */
+    removeRequestInterceptor(id) {
+        this.requestInterceptors = this.requestInterceptors.filter(item => item.id !== id);
+    }
+    /**
+     * Remove a response interceptor by its ID
+     *
+     * @param id - The interceptor ID returned from addResponseInterceptor
+     *
+     * @example
+     * Config.getInstance().removeResponseInterceptor(id);
+     */
+    removeResponseInterceptor(id) {
+        this.responseInterceptors = this.responseInterceptors.filter(item => item.id !== id);
+    }
+    /**
+     * Remove an error interceptor by its ID
+     *
+     * @param id - The interceptor ID returned from addErrorInterceptor
+     *
+     * @example
+     * Config.getInstance().removeErrorInterceptor(id);
+     */
+    removeErrorInterceptor(id) {
+        this.errorInterceptors = this.errorInterceptors.filter(item => item.id !== id);
+    }
+    /**
+     * Clear all interceptors (request, response, and error)
+     *
+     * @example
+     * Config.getInstance().clearInterceptors();
+     */
+    clearInterceptors() {
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.errorInterceptors = [];
+    }
+    /**
+     * Get all global request interceptors (in registration order)
+     * @internal
+     */
+    getRequestInterceptors() {
+        return this.requestInterceptors.map(item => item.interceptor);
+    }
+    /**
+     * Get all global response interceptors (in registration order)
+     * @internal
+     */
+    getResponseInterceptors() {
+        return this.responseInterceptors.map(item => item.interceptor);
+    }
+    /**
+     * Get all global error interceptors (in registration order)
+     * @internal
+     */
+    getErrorInterceptors() {
+        return this.errorInterceptors.map(item => item.interceptor);
+    }
+    /**
+     * Reset all configuration options to their default values
+     *
+     * @returns The config instance for chaining
+     *
+     * @example
+     * Config.getInstance().reset();
+     */
+    reset() {
+        this.csrfToken = null;
+        this.csrfHeaderName = "X-CSRF-Token";
+        this.enableAntiCsrf = true;
+        this.xsrfCookieName = "XSRF-TOKEN";
+        this.xsrfHeaderName = "X-XSRF-TOKEN";
+        this.enableAutoXsrf = true;
+        this.clearInterceptors();
+        return this;
+    }
+}
+
+/**
+ * Base class with common functionality for all request types
+ * Provides the core request building and execution capabilities.
+ */
+class BaseRequest {
+    constructor(url) {
+        this.requestOptions = {
+            headers: {},
+        };
+        this.queryParams = new URLSearchParams();
+        this.autoApplyCsrfProtection = true;
+        // Per-request interceptors
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.errorInterceptors = [];
+        this.url = url;
+    }
+    /**
+     * Creates a fluent API for setting enum-based options
+     * Combines direct setter with convenience methods
+     */
+    createFluentSetter(optionName, options) {
+        const fluent = {};
+        // Create convenience methods for each enum value
+        Object.entries(options).forEach(([key, value]) => {
+            fluent[key] = () => {
+                this.requestOptions[optionName] = value;
+                return this;
+            };
+        });
+        // Create the callable setter
+        const callable = (value) => {
+            this.requestOptions[optionName] = value;
+            return this;
+        };
+        return Object.assign(callable, fluent);
+    }
+    validateUrl(url) {
+        if (!(url === null || url === void 0 ? void 0 : url.trim()))
+            throw new RequestError("URL cannot be empty", url, this.method);
+        if (url.includes("\0") || url.includes("\r") || url.includes("\n")) {
+            throw new RequestError("Invalid URL (control chars)", url, this.method);
+        }
+        const trimmed = url.trim();
+        if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+            try {
+                new URL(trimmed);
+            }
+            catch (_a) {
+                throw new RequestError(`Invalid URL: ${trimmed}`, trimmed, this.method);
+            }
+        }
+    }
+    /**
+     * Add multiple HTTP headers to the request
+     *
+     * @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 filteredHeaders = {};
+        Object.entries(headers).forEach(([key, value]) => {
+            if (value !== null && value !== undefined) {
+                filteredHeaders[key] = value;
+            }
+        });
+        this.requestOptions.headers = {
+            ...this.getHeadersRecord(),
+            ...filteredHeaders,
+        };
+        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) {
+        // Ignore null and undefined values
+        if (value !== null && value !== undefined) {
+            return this.withHeaders({ [key]: value });
+        }
+        return this;
+    }
+    /**
+     * Set a timeout for the request
+     * If the request takes longer than the specified timeout, it will be aborted.
+     *
+     * @param timeout - The timeout in milliseconds
+     * @returns The request instance for chaining
+     * @throws Error if timeout is not a positive number
+     *
+     * @example
+     * request.withTimeout(5000); // 5 seconds timeout
+     */
+    withTimeout(timeout) {
+        if (!Number.isFinite(timeout) || timeout <= 0)
+            throw new Error("Timeout must be a positive number");
+        this.requestOptions.timeout = timeout;
+        return this;
+    }
+    /**
+     * Configure automatic retry behavior for failed requests
+     *
+     * @param retries - Number of retry attempts before failing
+     * @returns The request instance for chaining
+     * @throws Error if retries is not a non-negative integer
+     *
+     * @example
+     * request.withRetries(3); // Retry up to 3 times
+     */
+    withRetries(retries) {
+        if (!Number.isInteger(retries) || retries < 0)
+            throw new Error("Retry count must be a non-negative integer");
+        this.requestOptions.retries = retries;
+        return this;
+    }
+    /**
+     * Set a callback to be invoked before each retry attempt
+     * Useful for implementing backoff strategies or logging retry attempts.
+     *
+     * @param callback - Function to call before retrying
+     * @returns The request instance for chaining
+     *
+     * @example
+     * request.onRetry(({ attempt, error }) => {
+     *   console.log(`Retry attempt ${attempt} after error: ${error.message}`);
+     *   return new Promise(resolve => setTimeout(resolve, attempt * 1000));
+     * });
+     */
+    onRetry(callback) {
+        this.requestOptions.onRetry = callback;
+        return this;
+    }
+    /**
+     * Sets credentials policy - supports both direct call and fluent API
+     * @example
+     * request.withCredentials("include")
+     * request.withCredentials(CredentialsPolicy.INCLUDE)
+     * request.withCredentials.INCLUDE()
+     */
+    get withCredentials() {
+        return this.createFluentSetter("credentials", {
+            INCLUDE: CredentialsPolicy.INCLUDE,
+            OMIT: CredentialsPolicy.OMIT,
+            SAME_ORIGIN: CredentialsPolicy.SAME_ORIGIN,
+        });
+    }
+    /**
+     * Allows providing an external AbortController to cancel the request
+     * @param controller - The AbortController to use for this request
+     * @returns The instance for chaining
+     */
+    withAbortController(controller) {
+        this.abortController = controller;
+        return this;
+    }
+    /**
+     * Sets the referrer for the request
+     * @param referrer - The referrer URL or policy
+     * @returns The instance for chaining
+     */
+    withReferrer(referrer) {
+        this.requestOptions.referrer = referrer;
+        return this;
+    }
+    /**
+     * Sets referrer policy - supports both direct call and fluent API
+     * @example
+     * request.withReferrerPolicy("no-referrer")
+     * request.withReferrerPolicy(ReferrerPolicy.NO_REFERRER)
+     * request.withReferrerPolicy.NO_REFERRER()
+     */
+    get withReferrerPolicy() {
+        return this.createFluentSetter("referrerPolicy", {
+            ORIGIN: ReferrerPolicy.ORIGIN,
+            UNSAFE_URL: ReferrerPolicy.UNSAFE_URL,
+            SAME_ORIGIN: ReferrerPolicy.SAME_ORIGIN,
+            NO_REFERRER: ReferrerPolicy.NO_REFERRER,
+            STRICT_ORIGIN: ReferrerPolicy.STRICT_ORIGIN,
+            ORIGIN_WHEN_CROSS_ORIGIN: ReferrerPolicy.ORIGIN_WHEN_CROSS_ORIGIN,
+            NO_REFERRER_WHEN_DOWNGRADE: ReferrerPolicy.NO_REFERRER_WHEN_DOWNGRADE,
+            STRICT_ORIGIN_WHEN_CROSS_ORIGIN: ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
+        });
+    }
+    /**
+     * Sets redirect mode - supports both direct call and fluent API
+     * @example
+     * request.withRedirect("follow")
+     * request.withRedirect(RedirectMode.FOLLOW)
+     * request.withRedirect.FOLLOW()
+     */
+    get withRedirect() {
+        return this.createFluentSetter("redirect", {
+            FOLLOW: RedirectMode.FOLLOW,
+            ERROR: RedirectMode.ERROR,
+            MANUAL: RedirectMode.MANUAL,
+        });
+    }
+    /**
+     * Sets the keepalive flag for the request
+     * @param keepalive - Whether to allow the request to outlive the page
+     * @returns The instance for chaining
+     */
+    withKeepAlive(keepalive) {
+        this.requestOptions.keepalive = keepalive;
+        return this;
+    }
+    /**
+     * Sets request priority - supports both direct call and fluent API
+     * @example
+     * request.withPriority("high")
+     * request.withPriority(RequestPriority.HIGH)
+     * request.withPriority.HIGH()
+     */
+    get withPriority() {
+        return this.createFluentSetter("priority", {
+            HIGH: RequestPriority.HIGH,
+            LOW: RequestPriority.LOW,
+            AUTO: RequestPriority.AUTO,
+        });
+    }
+    /**
+     * Adds query parameters to the request URL
+     * @param params - An object containing the query parameters
+     * @returns The instance for chaining
+     */
+    withQueryParams(params) {
+        Object.entries(params).forEach(([key, value]) => {
+            if (value === null || value === undefined) {
+                return;
+            }
+            if (Array.isArray(value)) {
+                // Handle array values - add multiple entries with the same key
+                value.forEach(v => this.queryParams.append(key, String(v)));
+            }
+            else {
+                this.queryParams.append(key, String(value));
+            }
+        });
+        return this;
+    }
+    /**
+     * Adds a single query parameter
+     * @param key - The parameter name
+     * @param value - The parameter value, can be a single value or array of values
+     * @returns The instance for chaining
+     */
+    withQueryParam(key, value) {
+        if (value === null || value === undefined)
+            return this;
+        if (Array.isArray(value))
+            value.forEach(v => this.queryParams.append(key, String(v)));
+        else
+            this.queryParams.append(key, String(value));
+        return this;
+    }
+    /**
+     * Sets request mode - supports both direct call and fluent API
+     * @example
+     * request.withMode("cors")
+     * request.withMode(RequestMode.CORS)
+     * request.withMode.CORS()
+     */
+    get withMode() {
+        return this.createFluentSetter("mode", {
+            CORS: RequestMode.CORS,
+            NO_CORS: RequestMode.NO_CORS,
+            SAME_ORIGIN: RequestMode.SAME_ORIGIN,
+            NAVIGATE: RequestMode.NAVIGATE,
+        });
+    }
+    /**
+     * Shorthand for setting the Content-Type header
+     * @param contentType - The content type
+     * @returns The instance for chaining
+     */
+    withContentType(contentType) {
+        return this.withHeaders({
+            "Content-Type": contentType,
+        });
+    }
+    /**
+     * Shorthand for setting the Authorization header
+     * @param authValue - The authorization value
+     * @returns The instance for chaining
+     */
+    withAuthorization(authValue) {
+        return this.withHeaders({
+            Authorization: authValue,
+        });
+    }
+    /**
+     * Shorthand for setting up Basic authentication
+     * @param username - The username
+     * @param password - The password
+     * @returns The instance for chaining
+     */
+    withBasicAuth(username, password) {
+        const credentials = this.encodeBase64(`${username}:${password}`);
+        return this.withAuthorization(`Basic ${credentials}`);
+    }
+    /**
+     * Cross-environment base64 encoding
+     * Works in both browser and Node.js environments
+     */
+    encodeBase64(str) {
+        // Modern approach using TextEncoder (available in both modern browsers and Node.js)
+        if (typeof TextEncoder !== "undefined" && typeof btoa === "function") {
+            const encoder = new TextEncoder();
+            const bytes = encoder.encode(str);
+            return btoa(String.fromCharCode.apply(null, [...new Uint8Array(bytes)]));
+        }
+        // Browser environment
+        if (typeof btoa === "function")
+            return btoa(str);
+        // Node.js environment
+        if (typeof Buffer !== "undefined")
+            return Buffer.from(str).toString("base64");
+        // Fallback (should never happen in modern environments)
+        throw new Error("Base64 encoding is not supported");
+    }
+    /**
+     * Sets the bearer token for authentication
+     * @param token - The bearer token
+     * @returns The instance for chaining
+     */
+    withBearerToken(token) {
+        return this.withAuthorization(`Bearer ${token}`);
+    }
+    /**
+     * Safely get headers as a Record<string, string>
+     * @returns The headers object
+     */
+    getHeadersRecord() {
+        if (typeof this.requestOptions.headers === "object" && this.requestOptions.headers !== null) {
+            return this.requestOptions.headers;
+        }
+        return {};
+    }
+    /**
+     * Helper function to check for header presence in a case-insensitive way
+     * @param headerName Header name to check
+     * @returns Boolean indicating if the header exists (case-insensitive)
+     */
+    hasHeader(headerName) {
+        const headers = this.getHeadersRecord();
+        return Object.keys(headers).some(key => key.toLowerCase() === headerName.toLowerCase());
+    }
+    /**
+     * Sets cookies for the request
+     * @param cookies Object containing cookie name-value pairs or cookie options
+     * @returns The instance for chaining
+     */
+    withCookies(cookies) {
+        const cookieEntries = Object.entries(cookies || {});
+        if (cookieEntries.length === 0) {
+            return this;
+        }
+        const currentHeaders = this.getHeadersRecord();
+        // Get all existing cookie headers with different cases
+        const cookieValues = [];
+        const cookieHeaderKeys = [];
+        Object.keys(currentHeaders).forEach(key => {
+            if (key.toLowerCase() === "cookie") {
+                // Don't add empty cookie values
+                if (currentHeaders[key])
+                    cookieValues.push(currentHeaders[key]);
+                cookieHeaderKeys.push(key);
+            }
+        });
+        // Format the new cookies
+        const cookieString = CookieUtils.formatRequestCookies(cookies);
+        // Choose which header name to use - preserve existing case if possible
+        const headerName = cookieHeaderKeys.length > 0 ? cookieHeaderKeys[0] : "Cookie";
+        // Combine all existing cookie values with the new ones
+        const combinedCookieValue = [...cookieValues, cookieString].filter(Boolean).join("; ");
+        // Create a new headers object without any cookie headers
+        const newHeaders = { ...currentHeaders };
+        cookieHeaderKeys.forEach(key => {
+            delete newHeaders[key];
+        });
+        // Set the new combined cookie header
+        this.requestOptions.headers = {
+            ...newHeaders,
+            [headerName]: combinedCookieValue,
+        };
+        return this;
+    }
+    /**
+     * Set a single cookie
+     * @param name Cookie name
+     * @param value Cookie value or options object
+     * @returns The instance for chaining
+     */
+    withCookie(name, value) {
+        return this.withCookies({ [name]: value });
+    }
+    /**
+     * Sets a CSRF token in the request headers
+     * @param token The CSRF token
+     * @param headerName The name of the header to use (default: X-CSRF-Token)
+     * @returns The instance for chaining
+     */
+    withCsrfToken(token, headerName = "X-CSRF-Token") {
+        return this.withHeaders({
+            [headerName]: token,
+        });
+    }
+    /**
+     * Disables automatic anti-CSRF protection.
+     * By default, X-Requested-With: XMLHttpRequest header is sent with all requests.
+     * @returns The instance for chaining
+     */
+    withoutCsrfProtection() {
+        this.autoApplyCsrfProtection = false;
+        return this;
+    }
+    /**
+     * Sets common security headers to help prevent CSRF attacks
+     * @returns The instance for chaining
+     */
+    withAntiCsrfHeaders() {
+        return this.withHeaders({
+            "X-Requested-With": "XMLHttpRequest",
+        });
+    }
+    /**
+     * 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.requestInterceptors.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.responseInterceptors.push(interceptor);
+        return this;
+    }
+    /**
+     * Add an error interceptor for this specific request
+     * Error interceptors can handle or transform errors
+     *
+     * @param interceptor - The error interceptor function
+     * @returns The instance for chaining
+     *
+     * @example
+     * request.withErrorInterceptor((error) => {
+     *   console.error('Request failed:', error);
+     *   throw error;
+     * });
+     */
+    withErrorInterceptor(interceptor) {
+        this.errorInterceptors.push(interceptor);
+        return this;
+    }
+    /**
+     * Execute the request and return the ResponseWrapper
+     * This is the base method for getting the full response.
+     *
+     * @returns A promise that resolves to the ResponseWrapper
+     *
+     * @example
+     * const response = await request.getResponse();
+     * console.log(response.status);
+     */
+    async getResponse() {
+        const url = this.formatUrlWithQueryParams(this.url);
+        this.applyCsrfProtection();
+        const fetchOptions = {
+            ...this.requestOptions,
+            method: this.method,
+        };
+        return !this.requestOptions.retries ? this.executeRequest(url, fetchOptions) : this.executeWithRetries(url, fetchOptions);
+    }
+    /**
+     * Execute the request and parse the response as JSON
+     *
+     * @returns A promise that resolves to the parsed JSON data
+     *
+     * @example
+     * const users = await request.getJson<User[]>();
+     */
+    async getJson() {
+        const response = await this.getResponse();
+        return response.getJson();
+    }
+    /**
+     * Execute the request and get the response as text
+     *
+     * @returns A promise that resolves to the response text
+     *
+     * @example
+     * const text = await request.getText();
+     */
+    async getText() {
+        const response = await this.getResponse();
+        return response.getText();
+    }
+    /**
+     * Execute the request and get the response as a Blob
+     *
+     * @returns A promise that resolves to the response Blob
+     *
+     * @example
+     * const blob = await request.getBlob();
+     */
+    async getBlob() {
+        const response = await this.getResponse();
+        return response.getBlob();
+    }
+    /**
+     * Execute the request and get the response body as a ReadableStream
+     *
+     * @returns A promise that resolves to the response body stream
+     *
+     * @example
+     * const stream = await request.getBody();
+     */
+    async getBody() {
+        const response = await this.getResponse();
+        return response.getBody();
+    }
+    /**
+     * Execute the request and extract specific data using a selector function
+     * If no selector is provided, returns the full JSON response.
+     *
+     * @param selector - Optional function to extract and transform data
+     * @returns A promise that resolves to the selected data
+     *
+     * @example
+     * // Get full response
+     * const data = await request.getData();
+     *
+     * // Extract specific data
+     * const users = await request.getData(data => data.results.users);
+     */
+    async getData(selector) {
+        const response = await this.getResponse();
+        return response.getData(selector);
+    }
+    /**
+     * Apply CSRF protection headers based on configuration
+     */
+    applyCsrfProtection() {
+        if (!this.autoApplyCsrfProtection)
+            return;
+        const config = Config.getInstance();
+        // Apply anti-CSRF headers if enabled
+        if (config.isAntiCsrfEnabled()) {
+            this.withHeaders({
+                "X-Requested-With": "XMLHttpRequest",
+            });
+        }
+        // Apply global CSRF token if set
+        const globalToken = config.getCsrfToken();
+        if (globalToken) {
+            const csrfHeaderName = config.getCsrfHeaderName();
+            const hasLocalToken = this.hasHeader("X-CSRF-Token") || this.hasHeader(csrfHeaderName);
+            if (!hasLocalToken) {
+                this.withHeaders({
+                    [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.withHeaders({
+                        [xsrfHeaderName]: xsrfToken,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Formats the URL with any query parameters
+     * @param url The base URL
+     * @returns The URL with query parameters appended
+     */
+    formatUrlWithQueryParams(url) {
+        if (!this.queryParams.toString()) {
+            return url;
+        }
+        try {
+            // Try to use the URL constructor (works for absolute URLs)
+            const urlObj = new URL(url);
+            // Merge our query params with any that might be in the URL already
+            this.queryParams.forEach((value, key) => {
+                urlObj.searchParams.append(key, value);
+            });
+            return urlObj.toString();
+        }
+        catch (error) {
+            // Handle relative URLs
+            const hasExistingParams = url.includes("?");
+            const separator = hasExistingParams ? "&" : "?";
+            return `${url}${separator}${this.queryParams.toString()}`;
+        }
+    }
+    /**
+     * Executes a request with configured retry logic
+     * @param url The formatted URL to send the request to
+     * @param fetchOptions The fetch options to use
+     * @returns A wrapped response object
+     * @throws RequestError if the request fails after all retries
+     */
+    async executeWithRetries(url, fetchOptions) {
+        const maxRetries = this.requestOptions.retries || 0;
+        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await this.executeRequest(url, fetchOptions);
+            }
+            catch (error) {
+                const requestError = error instanceof RequestError ? error : RequestError.networkError(url, method, error instanceof Error ? error : new Error(String(error)));
+                if (attempt >= maxRetries)
+                    throw requestError;
+                if (this.requestOptions.onRetry) {
+                    await this.requestOptions.onRetry({ attempt: attempt + 1, error: requestError });
+                }
+            }
+        }
+        // This should never happen but is needed for type safety
+        throw new RequestError(`Max retries reached`, 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 runRequestInterceptors(configParam) {
+        const globalConfig = Config.getInstance();
+        const allInterceptors = [...globalConfig.getRequestInterceptors(), ...this.requestInterceptors];
+        let currentConfig = configParam;
+        for (let i = 0; i < allInterceptors.length; i++) {
+            try {
+                const result = await allInterceptors[i](currentConfig);
+                // If interceptor returns a Response, short-circuit
+                if (result instanceof Response) {
+                    return result;
+                }
+                currentConfig = result;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Use RequestError when we have request context
+                throw new RequestError(`Interceptor failed: ${errorMessage}`, currentConfig.url, currentConfig.method);
+            }
+        }
+        return currentConfig;
+    }
+    /**
+     * Run response interceptors in reverse order: per-request interceptors first, then global in reverse
+     * @param response - The response wrapper
+     * @returns Modified response wrapper
+     */
+    async runResponseInterceptors(response) {
+        const globalConfig = Config.getInstance();
+        const globalInterceptors = globalConfig.getResponseInterceptors();
+        // Per-request in order, then global in reverse
+        const allInterceptors = [...this.responseInterceptors, ...globalInterceptors.reverse()];
+        let currentResponse = response;
+        for (let i = 0; i < allInterceptors.length; i++) {
+            try {
+                currentResponse = await allInterceptors[i](currentResponse);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Use RequestError when we have response context (url/method from ResponseWrapper)
+                if (currentResponse.url && currentResponse.method) {
+                    throw new RequestError(`Interceptor failed: ${errorMessage}`, currentResponse.url, currentResponse.method);
+                }
+                // Fallback to generic Error if no context available (shouldn't happen in practice)
+                throw new Error(`Interceptor failed: ${errorMessage}`);
+            }
+        }
+        return currentResponse;
+    }
+    /**
+     * Run error interceptors in reverse order: per-request interceptors first, then global in reverse
+     * @param error - The error that occurred
+     * @returns Modified error or a ResponseWrapper to recover
+     */
+    async runErrorInterceptors(error) {
+        const globalConfig = Config.getInstance();
+        const globalInterceptors = globalConfig.getErrorInterceptors();
+        // Per-request in order, then global in reverse
+        const allInterceptors = [...this.errorInterceptors, ...globalInterceptors.reverse()];
+        let currentError = error;
+        for (let i = 0; i < allInterceptors.length; i++) {
+            try {
+                // If previous interceptor recovered with a response, stop processing
+                if (currentError instanceof ResponseWrapper) {
+                    return currentError;
+                }
+                const result = await allInterceptors[i](currentError);
+                currentError = result;
+            }
+            catch (interceptorError) {
+                // If an error interceptor throws, that becomes the new error
+                if (interceptorError instanceof RequestError) {
+                    currentError = interceptorError;
+                }
+                else {
+                    const errorMessage = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
+                    // Always wrap in RequestError when we have context
+                    if (currentError instanceof RequestError) {
+                        currentError = new RequestError(`Error interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method);
+                    }
+                    else if (currentError instanceof ResponseWrapper && currentError.url && currentError.method) {
+                        // If it's a ResponseWrapper, we can still create a proper RequestError from its context
+                        currentError = new RequestError(`Error interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method);
+                    }
+                    else {
+                        // Last resort: if we have no context at all, use the original error's context
+                        // This shouldn't happen in practice, but handle it gracefully
+                        const errorObj = interceptorError instanceof Error ? interceptorError : new Error(String(interceptorError));
+                        currentError = RequestError.networkError(error.url, error.method, errorObj);
+                    }
+                }
+            }
+        }
+        return currentError;
+    }
+    /**
+     * Helper to create an abort signal with timeout support
+     * Handles various AbortSignal API levels gracefully
+     */
+    createAbortSignal(timeoutMs, externalController) {
+        let timeoutId;
+        let timeoutController;
+        let isTimeout = false;
+        // No timeout - just use external controller
+        if (!timeoutMs) {
+            return {
+                signal: externalController === null || externalController === void 0 ? void 0 : externalController.signal,
+                cleanup: () => { },
+                wasTimeout: () => false,
+            };
+        }
+        // Check if AbortSignal.any() is available (modern browsers)
+        const hasAbortSignalAny = typeof AbortSignal.any === "function";
+        const hasAbortSignalTimeout = typeof AbortSignal.timeout === "function";
+        // Create timeout signal
+        const createTimeoutSignal = () => {
+            if (hasAbortSignalTimeout) {
+                const signal = AbortSignal.timeout(timeoutMs);
+                signal.addEventListener("abort", () => (isTimeout = true), { once: true });
+                return signal;
+            }
+            else {
+                timeoutController = new AbortController();
+                timeoutId = setTimeout(() => {
+                    isTimeout = true;
+                    timeoutController.abort();
+                }, timeoutMs);
+                return timeoutController.signal;
+            }
+        };
+        const timeoutSignal = createTimeoutSignal();
+        // Combine signals if we have both timeout and external controller
+        const finalSignal = externalController && hasAbortSignalAny
+            ? AbortSignal.any([externalController.signal, timeoutSignal])
+            : externalController
+                ? this.combineSignalsManually(externalController.signal, timeoutSignal)
+                : timeoutSignal;
+        return {
+            signal: finalSignal,
+            cleanup: () => {
+                if (timeoutId !== undefined)
+                    clearTimeout(timeoutId);
+            },
+            wasTimeout: () => isTimeout,
+        };
+    }
+    /**
+     * Manually combine two abort signals for older environments
+     * Returns the first signal and listens to the second
+     */
+    combineSignalsManually(signal1, signal2) {
+        // If either is already aborted, use that one
+        if (signal1.aborted)
+            return signal1;
+        if (signal2.aborted)
+            return signal2;
+        // Use a controller to create a combined signal
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        signal1.addEventListener("abort", abort, { once: true });
+        signal2.addEventListener("abort", abort, { once: true });
+        return controller.signal;
+    }
+    /**
+     * Convert fetchOptions to RequestConfig with proper typing
+     */
+    createRequestConfig(url, fetchOptions) {
+        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
+        const headers = this.getHeadersRecord();
+        const extendedOptions = fetchOptions;
+        return {
+            url,
+            method,
+            headers,
+            body: fetchOptions.body,
+            signal: fetchOptions.signal || undefined,
+            credentials: fetchOptions.credentials,
+            mode: fetchOptions.mode,
+            redirect: fetchOptions.redirect,
+            referrer: fetchOptions.referrer,
+            referrerPolicy: fetchOptions.referrerPolicy,
+            keepalive: fetchOptions.keepalive,
+            priority: extendedOptions.priority,
+        };
+    }
+    /**
+     * Apply interceptor results back to fetchOptions
+     */
+    applyRequestConfig(config, fetchOptions) {
+        fetchOptions.headers = config.headers;
+        if (config.body !== undefined) {
+            fetchOptions.body = config.body;
+        }
+    }
+    async executeRequest(url, fetchOptions) {
+        const method = typeof fetchOptions.method === "string" ? fetchOptions.method : "GET";
+        // Setup abort signal with timeout
+        const abortSignal = this.createAbortSignal(this.requestOptions.timeout, this.abortController);
+        try {
+            // Run request interceptors before making the request
+            const requestConfig = this.createRequestConfig(url, fetchOptions);
+            const interceptorResult = await this.runRequestInterceptors(requestConfig);
+            // If interceptor returned a Response, short-circuit and wrap it
+            if (interceptorResult instanceof Response) {
+                const wrappedResponse = new ResponseWrapper(interceptorResult, this.url, this.method);
+                return await this.runResponseInterceptors(wrappedResponse);
+            }
+            // Update fetchOptions with interceptor modifications
+            url = interceptorResult.url;
+            this.validateUrl(url);
+            this.applyRequestConfig(interceptorResult, fetchOptions);
+            // Set the combined abort signal
+            fetchOptions.signal = abortSignal.signal;
+            // Execute fetch
+            let response;
+            try {
+                response = await fetch(url, fetchOptions);
+            }
+            catch (error) {
+                // Check if it's an abort error (DOMException in browsers, or AbortSignal abort)
+                if (error instanceof DOMException && error.name === "AbortError") {
+                    if (abortSignal.wasTimeout()) {
+                        throw RequestError.timeout(url, method, this.requestOptions.timeout);
+                    }
+                    throw RequestError.abortError(url, method);
+                }
+                // Check for Node.js/undici TimeoutError
+                const errorObj = error instanceof Error ? error : new Error(String(error));
+                const errorName = errorObj.name;
+                const errorMessage = errorObj.message.toLowerCase();
+                // Detect timeout errors from Node.js/undici (TimeoutError)
+                const isTimeoutError = errorName === "TimeoutError" || errorMessage.includes("timeout") || errorMessage.includes("aborted due to timeout") || abortSignal.wasTimeout();
+                if (isTimeoutError && this.requestOptions.timeout) {
+                    throw RequestError.timeout(url, method, this.requestOptions.timeout);
+                }
+                throw RequestError.networkError(url, method, errorObj);
+            }
+            if (!response.ok) {
+                throw RequestError.fromResponse(response, url, method);
+            }
+            const wrappedResponse = new ResponseWrapper(response, url, method);
+            return await this.runResponseInterceptors(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);
+            }
+            // Run error interceptors
+            const interceptorResult = await this.runErrorInterceptors(requestError);
+            // If error interceptor returned a ResponseWrapper, recover from error
+            if (interceptorResult instanceof ResponseWrapper) {
+                return interceptorResult;
+            }
+            throw interceptorResult;
+        }
+        finally {
+            abortSignal.cleanup();
+        }
+    }
+}
+
+/**
+ * Base class for requests that can have a body (POST, PUT, PATCH)
+ */
+class BodyRequest extends BaseRequest {
+    constructor(url) {
+        super(url);
+    }
+    /**
+     * Sets the body of the request
+     * @param body - The request body
+     */
+    withBody(body) {
+        this.body = body;
+        // Set body type and validate
+        if (typeof body === "string") {
+            this.bodyType = BodyType.STRING;
+            this.setContentTypeIfNeeded("text/plain");
+        }
+        else if (body !== null &&
+            typeof body === "object" &&
+            !(body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer || body instanceof URLSearchParams || body instanceof ReadableStream)) {
+            this.bodyType = BodyType.JSON;
+            this.setContentTypeIfNeeded("application/json");
+            // Validate JSON is stringifiable early
+            try {
+                JSON.stringify(body);
+            }
+            catch (error) {
+                throw new RequestError(`Stringify failed: ${String(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
+     *
+     * @param query - The GraphQL query or mutation string
+     * @param variables - Optional variables object to pass with the query
+     * @returns The request instance for chaining
+     *
+     * @example
+     * const request = new PostRequest('/graphql')
+     *   .withGraphQL('query { user(id: $id) { name email } }', { id: '123' });
+     *
+     * @example
+     * const request = new PostRequest('/graphql')
+     *   .withGraphQL('mutation { createUser(name: $name) { id } }', { name: 'John' });
+     */
+    withGraphQL(query, variables) {
+        if (typeof query !== "string" || query.trim().length === 0) {
+            throw new RequestError("Invalid GraphQL query", this.url, this.method);
+        }
+        const graphQLBody = {
+            query: query.trim(),
+        };
+        if (variables !== undefined) {
+            if (typeof variables !== "object" || variables === null || Array.isArray(variables)) {
+                throw new RequestError("Invalid GraphQL variables", this.url, this.method);
+            }
+            graphQLBody.variables = variables;
+        }
+        // Validate JSON is stringifiable early
+        try {
+            JSON.stringify(graphQLBody);
+        }
+        catch (error) {
+            throw new RequestError(`Stringify failed: ${String(error)}`, this.url, this.method);
+        }
+        this.body = graphQLBody;
+        this.bodyType = BodyType.JSON;
+        this.setContentTypeIfNeeded("application/json");
+        return this;
+    }
+    /**
+     * Check if Content-Type header is already set (case-insensitive)
+     */
+    hasContentType() {
+        const headers = this.requestOptions.headers;
+        if (typeof headers === "object" && headers !== null) {
+            const headersObj = headers;
+            return Object.keys(headersObj).some(header => header.toLowerCase() === "content-type");
+        }
+        return false;
+    }
+    setContentTypeIfNeeded(contentType) {
+        if (!this.hasContentType()) {
+            this.withContentType(contentType);
+        }
+    }
+    /**
+     * 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.requestOptions.body)
+                delete this.requestOptions.body;
+            // Process the body based on its type
+            if (this.bodyType === BodyType.JSON) {
+                this.requestOptions.body = JSON.stringify(this.body);
+            }
+            else {
+                this.requestOptions.body = this.body;
+            }
+        }
+        return super.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 {
+    constructor(url) {
+        super(url);
+        this.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 {
+    constructor(url) {
+        super(url);
+        this.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 {
+    constructor(url) {
+        super(url);
+        this.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 {
+    constructor(url) {
+        super(url);
+        this.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')
+ *   .withJson({ name: 'John', email: 'john@example.com' });
+ * const data = await request.getData();
+ */
+class PostRequest extends BodyRequest {
+    constructor(url) {
+        super(url);
+        this.method = HttpMethod.POST;
+    }
+}
+/**
+ * HTTP PUT request implementation
+ * Used to replace or update an existing resource.
+ *
+ * @example
+ * const request = new PutRequest('/api/users/123')
+ *   .withJson({ id: '123', name: 'John', email: 'john@example.com' });
+ * const data = await request.getData();
+ */
+class PutRequest extends BodyRequest {
+    constructor(url) {
+        super(url);
+        this.method = HttpMethod.PUT;
+    }
+}
+/**
+ * HTTP PATCH request implementation
+ * Used to apply partial modifications to a resource.
+ *
+ * @example
+ * const request = new PatchRequest('/api/users/123')
+ *   .withJson({ email: 'new.email@example.com' });
+ * const data = await request.getData();
+ */
+class PatchRequest extends BodyRequest {
+    constructor(url) {
+        super(url);
+        this.method = HttpMethod.PATCH;
+    }
+}
+
+/**
+ * Create a GET request
+ * Used for retrieving resources from the server.
+ *
+ * @param url - The URL to send the request to
+ * @returns A new GET request instance
+ *
+ * @example
+ * const 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')
+ *   .withJson({ 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')
+ *   .withJson({ 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')
+ *   .withJson({ 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);
+}
+
+/**
+ * Main API object for creating HTTP requests
+ * Provides factory methods for all HTTP methods and access to global configuration.
+ */
+const create = {
+    get,
+    post,
+    put,
+    del,
+    patch,
+    head,
+    options,
+    config: Config.getInstance(),
+};
+
+export { CookieUtils, CredentialsPolicy, DeleteRequest, GetRequest, HeadRequest, HttpMethod, OptionsRequest, PatchRequest, PostRequest, PutRequest, RedirectMode, ReferrerPolicy, RequestError, RequestMode, RequestPriority, ResponseWrapper, SameSitePolicy, create as default };
+//# sourceMappingURL=index.esm.js.map