ajax-hooker 1.2.0 → 1.2.2

package/dist/esm/index.js

@@ -1 +1,613 @@
-const e="xhr",t="fetch",r=Symbol("CycleScheduler");class s{req={};resp={};constructor({req:e={}}={}){this.req=e}async execute(e,t){let r=e;for(const e of t){const t=await e(r);t&&(r=t)}return r}}Object.getOwnPropertyDescriptor.bind(Object);const n=Object.prototype.toString.call.bind(Object.prototype.toString),o=(e="")=>new URL(e,window.location.origin).toString(),a=(e,t)=>{const r=Reflect.get(e,t);return"function"!=typeof r?r:function(...t){return Reflect.apply(r,e,t)}},c=({source:e,target:t,prototype:r})=>{Object.keys(e).forEach(r=>{t[r]=e[r]}),t.prototype=r};class h{nativeXhr=window.XMLHttpRequest;nativeXhrPrototype=window.XMLHttpRequest.prototype;hooks=[];xhrResponseEvents=["readystatechange","load","loadend"];xhrInstanceAttr=["response","responseText","responseXML","status","statusText"];xhrInstanceAttrHandler=this.xhrInstanceAttr.reduce((e,t)=>(e[t]=function(e){const s=e[r];return s.xhrAlreadyReturned?s.resp[t]:e[t]},e),{});xhrMethodsHandler={open:function(t,s){return function(...n){const a=s[r];a.xhrReset(),a.req={type:e,method:n[0]||"GET",url:o(n[1]),headers:new Headers,data:null,response:()=>{}},a.xhrOpenRestArgs=n.slice(2),t.nativeXhrPrototype.open.apply(s,[a.req.method,a.req.url,...a.xhrOpenRestArgs||[]])}},send:function(e,t){return async function(s){const n=t[r];n.req.data=s??null,n.req.responseType=t.responseType,n.req.withCredentials=t.withCredentials,n.req.timeout=t.timeout,n.req.headers=new Headers(n.xhrSetRequestHeadersAfterOpen);const o=n.req;let a={...n.req,headers:new Headers(n.req.headers)};try{a=await n.execute(a,e.hooks)}catch(e){console.warn("[AjaxInterceptor] Error in xhr request hooks:",e)}n.req=a;const c=o.method!==a.method||o.url!==a.url;c&&e.nativeXhrPrototype.open.apply(t,[n.req.method,n.req.url,...n.xhrOpenRestArgs||[]]);const h=["responseType","withCredentials","timeout"];for(const e of h)a[e]!==o[e]&&(t[e]=a[e]);!c&&e.headersEqual(o.headers,a.headers)||n.req.headers.forEach((e,r)=>{t.setRequestHeader(r,e)}),e.nativeXhrPrototype.send.apply(t,[n.req.data])}},setRequestHeader:function(e,t){return function(s,n){const o=t[r];e.nativeXhrPrototype.setRequestHeader.apply(t,[s,n]),o.xhrSetRequestHeadersAfterOpen.append(s,n)}},addEventListener:function(e,t,r){return function(s,n,...o){const a=e.xhrResponseEvents.includes(s);t.addEventListener(s,async function(...s){a&&4===t.readyState&&await e.responseProcessor(t),Reflect.apply(n,r,s)},...o)}}};constructor(){}inject(){window.XMLHttpRequest=this._generateProxyXMLHttpRequest()}uninject(){window.XMLHttpRequest=this.nativeXhr}parseHeaders(e){const t={};if(!e)return t;const r=(e,r)=>{const s=e.toLowerCase();t[s]=s in t?`${t[s]}, ${r}`:r},s=n(e);if("[object String]"===s){const t=e;for(const e of t.trim().split(/[\r\n]+/)){const t=e.indexOf(":");if(-1===t)continue;const s=e.slice(0,t).trim(),n=e.slice(t+1).trim();s&&r(s,n)}}else if("[object Headers]"===s){e.forEach((e,t)=>{r(t,e)})}else if("[object Object]"===s){const t=e;for(const[e,s]of Object.entries(t))null!=s&&r(e,String(s))}return t}async responseProcessor(e){const t=e[r];if(!t.xhrAlreadyReturned){t.xhrAlreadyReturned=!0,t.resp={status:e.status,statusText:e.statusText,response:e.response,headers:new Headers(this.parseHeaders(e.getAllResponseHeaders())),finalUrl:e.responseURL||""};try{await t.req.response(t.resp)}catch(e){console.warn("[AjaxInterceptor] Error in xhr response callback:",e)}}}headersEqual(e,t){if(e===t)return!0;const r=e=>{const t=[];return e.forEach((e,r)=>t.push(`${r}: ${e}`)),t.sort().toString()};return r(e)===r(t)}getAttrHandler(e,t,r){return this.xhrInstanceAttr.includes(t)?this.xhrInstanceAttrHandler[t](e):this.xhrMethodsHandler[t]?this.xhrMethodsHandler[t](this,e,r):null}_generateProxyXMLHttpRequest(){const e=this;function t(){const t=new e.nativeXhr;t[r]=new i;return new Proxy(t,{get:(t,r,s)=>e.getAttrHandler(t,r,s)??a(t,r),set(t,r,s,n){if("function"==typeof s&&r.startsWith("on")){const o=e.xhrResponseEvents.includes(r.replace(/^on/,"")),a=async function(...r){o&&4===t.readyState&&await e.responseProcessor(t),Reflect.apply(s,n,r)};return Reflect.set(t,r,a)}return Reflect.set(t,r,s)}})}return c({source:e.nativeXhr,target:t,prototype:this.nativeXhrPrototype}),t}}class i extends s{xhrAlreadyReturned=!1;xhrOpenRestArgs=[];xhrSetRequestHeadersAfterOpen=new Headers;xhrReset(){this.req={},this.resp={},this.xhrOpenRestArgs=[],this.xhrSetRequestHeadersAfterOpen=new Headers,this.xhrAlreadyReturned=!1}constructor({req:e={}}={}){super({req:e})}}class d extends s{constructor({req:e={}}={}){super({req:e})}}class u{nativeFetch=window.fetch;nativeFetchPrototype=this.nativeFetch.prototype;hooks=[];fetchInstanceAttr=["status","statusText","ok","headers","redirected"];fetchInstanceAttrHandler=this.fetchInstanceAttr.reduce((e,t)=>(e[t]=function(e,s){return s[r].resp[t]},e),{});fetchMethods=["json","formData","blob","arrayBuffer","text"];fetchMethodsHandler=this.fetchMethods.reduce((e,t)=>(e[t]=function(e,s){return async function(...e){return s[r].resp[t]}},e),{});constructor(){}inject(){window.fetch=this._generateProxyFetch()}uninject(){window.fetch=this.nativeFetch}getAttrHandler(e,t){return this.fetchInstanceAttr.includes(t)?this.fetchInstanceAttrHandler[t](this,e):this.fetchMethodsHandler[t]?this.fetchMethodsHandler[t](this,e):null}normalizeRequest(e){let t="",r=null,s=null,n=null;return"string"==typeof e||e instanceof URL?t=o(e):(t=o(e.url),r=e.method??null,s=e.headers??null,n=e.body??null),{url:t,method:r,headers:s,data:n}}resolveRequest(e,t,r){const s="string"==typeof e&&t.url!==e||e instanceof URL&&t.url!==e.href||e instanceof Request&&t.url!==e.url;if("string"==typeof e)return s?t.url:e;if(e instanceof URL)return s?new URL(t.url):e;if(e instanceof Request){if(s||"request"===r.method&&t.method!==e.method||"request"===r.headers&&t.headers!==e.headers||"request"===r.data&&t.data!==e.body){const n="request"===r.method&&t.method!==e.method,o="request"===r.headers&&t.headers!==e.headers,a="request"===r.data&&t.data!==e.body;return new Request(s?t.url:e,{...n&&{method:t.method},...o&&{headers:t.headers},...a&&{body:t.data}})}return e}return e}resolveOptions({options:e,newRequest:t,sourceMap:r}){const{method:s,headers:n,body:o,...a}=e||{},c={...a};if(("options"===r.method||"default"===r.method&&t.method!==(e?.method??"GET"))&&(c.method=t.method),"options"===r.headers)c.headers=t.headers;else if("default"===r.headers){let e=!0;if(t.headers instanceof Headers){let r=0;t.headers.forEach(()=>{r++}),e=0===r}else t.headers&&(e=0===Object.keys(t.headers).length);e||(c.headers=t.headers)}return("options"===r.data||"default"===r.data&&t.data!==(e?.body??null))&&(c.body=t.data),t.data instanceof ReadableStream&&(c.duplex="half"),c}resolveHeaders(e){return e instanceof Headers?e:new Headers(e)}_generateProxyFetch(){const e=this;async function s(s,n={}){const o=e.normalizeRequest(s),c=e.nativeFetch,h=new d,i={method:"default",headers:"default",data:"default"};s instanceof Request&&(i.method="request",i.headers="request",null!==s.body&&(i.data="request")),void 0!==n.method&&(i.method="options"),void 0!==n.headers&&(i.headers="options"),void 0!==n.body&&(i.data="options");const u={type:t,url:o.url,method:n.method??o.method??"GET",headers:e.resolveHeaders(n.headers??o.headers??new Headers),data:n.body??o.data??null,response:()=>{}};let l=u;try{l=await h.execute(u,e.hooks)}catch(e){console.warn("[AjaxInterceptor] Error in fetch request hooks:",e)}h.req=l;const p=await c(e.resolveRequest(s,l,i),e.resolveOptions({options:n,newRequest:l,sourceMap:i})),f=p.headers.get("content-type")||"",y=f.includes("text/event-stream")||f.includes("application/stream+json")||f.includes("application/x-ndjson")||f.includes("application/jsonl")||f.includes("application/json-seq");let w=p;if(y&&p.body){h.resp={status:p.status,statusText:p.statusText,ok:p.ok,headers:p.headers,finalUrl:p.url,redirected:p.redirected};try{await h.req.response(h.resp)}catch(e){console.warn("[AjaxInterceptor] Error in fetch stream response callback:",e)}let e=0;const{readable:t,writable:r}=new TransformStream({async transform(t,r){try{const s=(new TextDecoder).decode(t,{stream:!0});let n=s;if(h.req.onStreamChunk){const r={text:s,raw:t,index:e++,timestamp:Date.now()},o=await h.req.onStreamChunk(r);"string"==typeof o&&(n=o)}const o=new TextEncoder;r.enqueue(o.encode(n))}catch(e){r.enqueue(t)}}});p.body.pipeTo(r),w=new Response(t,{status:p.status,statusText:p.statusText,headers:p.headers})}else if(!y){const[e,t,r,s,n]=await Promise.allSettled([p.clone().json(),p.clone().text(),p.clone().arrayBuffer(),p.clone().blob(),p.clone().formData()]).then(e=>e.map(e=>"fulfilled"===e.status?e.value:null));h.resp={status:p.status,statusText:p.statusText,ok:p.ok,headers:p.headers,finalUrl:p.url,redirected:p.redirected,json:e,text:t,arrayBuffer:r,blob:s,formData:n};try{await h.req.response(h.resp)}catch(e){console.warn("[AjaxInterceptor] Error in fetch response callback:",e)}}w[r]=h;return new Proxy(w,{get(t,r){const s=e.getAttrHandler(t,r);return s||a(t,r)},set:(e,t,r)=>Reflect.set(e,t,r)})}return c({source:this.nativeFetch,target:s,prototype:this.nativeFetchPrototype}),s}}class l{xhrInterceptor;fetchInterceptor;static#e;static#t=Symbol("AjaxInterceptor");static getInstance(e={}){return l.#e||(l.#e=new l(l.#t,e)),l.#e}constructor(e,t={}){if(e!==l.#t)throw new Error("AjaxInterceptor is a singleton");this.xhrInterceptor=new h,this.fetchInterceptor=new u}toggleInject(r,s){switch(r){case e:this.xhrInterceptor[s]();break;case t:this.fetchInterceptor[s]();break;default:this.xhrInterceptor[s](),this.fetchInterceptor[s]()}}inject(e){if("undefined"==typeof window)throw new Error("AjaxInterceptor requires a browser environment");window.XMLHttpRequest||console.warn("XMLHttpRequest is not supported in this environment"),window.fetch||console.warn("Fetch API is not supported in this environment"),this.toggleInject(e,"inject")}uninject(e){this.toggleInject(e,"uninject")}hook(r,s){switch(s){case e:this.xhrInterceptor.hooks.push(r);break;case t:this.fetchInterceptor.hooks.push(r);break;default:this.xhrInterceptor.hooks.push(r),this.fetchInterceptor.hooks.push(r)}}unhook(r,s){const n=e=>{if(!r)return void(e.length=0);const t=e.indexOf(r);-1!==t&&e.splice(t,1)};switch(s){case e:n(this.xhrInterceptor.hooks);break;case t:n(this.fetchInterceptor.hooks);break;default:n(this.xhrInterceptor.hooks),n(this.fetchInterceptor.hooks)}}}export{l as AjaxInterceptor,l as default};
+const AJAX_TYPE = {
+    XHR: "xhr",
+    FETCH: "fetch"
+};
+
+const CYCLE_SCHEDULER = Symbol("CycleScheduler");
+
+class CycleScheduler {
+    req={};
+    resp={};
+    constructor({req: req = {}} = {}) {
+        this.req = req;
+    }
+    async execute(request, fnList) {
+        let result = request;
+        for (const fn of fnList) {
+            const newResult = await fn(result);
+            if (newResult) result = newResult;
+        }
+        return result;
+    }
+}
+
+Object.getOwnPropertyDescriptor.bind(Object);
+
+const getType = Object.prototype.toString.call.bind(Object.prototype.toString);
+
+const resolveUrl = (url = "") => new URL(url, window.location.origin).toString();
+
+const getProxyValue = (target, prop) => {
+    const value = Reflect.get(target, prop);
+    if (typeof value !== "function") return value;
+    return function(...args) {
+        return Reflect.apply(value, target, args);
+    };
+};
+
+const copyNativePropsAndPrototype = ({source: source, target: target, prototype: prototype}) => {
+    Object.keys(source).forEach(key => {
+        target[key] = source[key];
+    });
+    target.prototype = prototype;
+};
+
+class XhrInterceptor {
+    nativeXhr=window.XMLHttpRequest;
+    nativeXhrPrototype=window.XMLHttpRequest.prototype;
+    hooks=[];
+    xhrResponseEvents=[ "readystatechange", "load", "loadend" ];
+    xhrInstanceAttr=[ "response", "responseText", "responseXML", "status", "statusText" ];
+    xhrInstanceAttrHandler=this.xhrInstanceAttr.reduce((acc, attr) => {
+        acc[attr] = function(target) {
+            const hooker = target[CYCLE_SCHEDULER];
+            return hooker.xhrAlreadyReturned ? hooker.resp[attr] : target[attr];
+        };
+        return acc;
+    }, {});
+    xhrMethodsHandler={
+        open: function(self, target) {
+            return function(...args) {
+                const hooker = target[CYCLE_SCHEDULER];
+                hooker.xhrReset();
+                hooker.req = {
+                    type: AJAX_TYPE.XHR,
+                    method: args[0] || "GET",
+                    url: resolveUrl(args[1]),
+                    headers: new Headers,
+                    data: null,
+                    response: () => {}
+                };
+                hooker.xhrOpenRestArgs = args.slice(2);
+                self.nativeXhrPrototype.open.apply(target, [ hooker.req.method, hooker.req.url, ...hooker.xhrOpenRestArgs || [] ]);
+            };
+        },
+        send: function(self, target) {
+            return async function(body) {
+                const hooker = target[CYCLE_SCHEDULER];
+                hooker.req.data = body ?? null;
+                hooker.req.responseType = target.responseType;
+                hooker.req.withCredentials = target.withCredentials;
+                hooker.req.timeout = target.timeout;
+                hooker.req.headers = new Headers(hooker.xhrSetRequestHeadersAfterOpen);
+                const oldRequest = hooker.req;
+                let newRequest = {
+                    ...hooker.req,
+                    headers: new Headers(hooker.req.headers)
+                };
+                try {
+                    newRequest = await hooker.execute(newRequest, self.hooks);
+                } catch (error) {
+                    console.warn("[AjaxInterceptor] Error in xhr request hooks:", error);
+                }
+                hooker.req = newRequest;
+                const needReopen = oldRequest.method !== newRequest.method || oldRequest.url !== newRequest.url;
+                const headersChanged = !self.headersEqual(oldRequest.headers, newRequest.headers);
+                const shouldReopen = needReopen || headersChanged;
+                if (shouldReopen) self.nativeXhrPrototype.open.apply(target, [ hooker.req.method, hooker.req.url, ...hooker.xhrOpenRestArgs || [] ]);
+                const xhrProps = [ "responseType", "withCredentials", "timeout" ];
+                for (const prop of xhrProps) if (newRequest[prop] !== oldRequest[prop]) target[prop] = newRequest[prop];
+                if (shouldReopen) hooker.req.headers.forEach((val, key) => {
+                    target.setRequestHeader(key, val);
+                });
+                self.nativeXhrPrototype.send.apply(target, [ hooker.req.data ]);
+            };
+        },
+        setRequestHeader: function(self, target) {
+            return function(name, value) {
+                const hooker = target[CYCLE_SCHEDULER];
+                self.nativeXhrPrototype.setRequestHeader.apply(target, [ name, value ]);
+                hooker.xhrSetRequestHeadersAfterOpen.append(name, value);
+            };
+        },
+        addEventListener: function(self, target, receiver) {
+            return function(type, listener, ...args) {
+                const isResponseEvent = self.xhrResponseEvents.includes(type);
+                const hooker = target[CYCLE_SCHEDULER];
+                const capture = self.getCaptureOption(args[0]);
+                const newListener = async function(...args) {
+                    if (isResponseEvent && target.readyState === 4) await self.responseProcessor(target);
+                    if (typeof listener === "function") {
+                        Reflect.apply(listener, receiver, args);
+                        return;
+                    }
+                    const [event] = args;
+                    listener.handleEvent?.(event);
+                };
+                hooker.saveWrappedEventListener(type, capture, listener, newListener);
+                target.addEventListener(type, newListener, ...args);
+            };
+        },
+        removeEventListener: function(self, target) {
+            return function(type, listener, options) {
+                if (!listener) return self.nativeXhrPrototype.removeEventListener.apply(target, [ type, listener, options ]);
+                const hooker = target[CYCLE_SCHEDULER];
+                const capture = self.getCaptureOption(options);
+                const wrappedListener = hooker.getWrappedEventListener(type, capture, listener) || listener;
+                self.nativeXhrPrototype.removeEventListener.apply(target, [ type, wrappedListener, options ]);
+            };
+        }
+    };
+    constructor() {}
+    inject() {
+        window.XMLHttpRequest = this._generateProxyXMLHttpRequest();
+    }
+    uninject() {
+        window.XMLHttpRequest = this.nativeXhr;
+    }
+    parseHeaders(obj) {
+        const headers = {};
+        if (!obj) return headers;
+        const mergeHeader = (key, value) => {
+            const lkey = key.toLowerCase();
+            headers[lkey] = lkey in headers ? `${headers[lkey]}, ${value}` : value;
+        };
+        const type = getType(obj);
+        if (type === "[object String]") {
+            const str = obj;
+            for (const line of str.trim().split(/[\r\n]+/)) {
+                const colonIndex = line.indexOf(":");
+                if (colonIndex === -1) continue;
+                const header = line.slice(0, colonIndex).trim();
+                const value = line.slice(colonIndex + 1).trim();
+                if (!header) continue;
+                mergeHeader(header, value);
+            }
+        } else if (type === "[object Headers]") {
+            const headersObj = obj;
+            headersObj.forEach((val, key) => {
+                mergeHeader(key, val);
+            });
+        } else if (type === "[object Object]") {
+            const record = obj;
+            for (const [key, val] of Object.entries(record)) if (val != null) mergeHeader(key, String(val));
+        }
+        return headers;
+    }
+    async responseProcessor(target) {
+        const hooker = target[CYCLE_SCHEDULER];
+        if (hooker.xhrAlreadyReturned) return;
+        hooker.xhrAlreadyReturned = true;
+        let responseText;
+        if (target.responseType === "" || target.responseType === "text") try {
+            responseText = target.responseText;
+        } catch (_error) {}
+        let responseXML;
+        try {
+            responseXML = target.responseXML;
+        } catch (_error) {}
+        hooker.resp = {
+            status: target.status,
+            statusText: target.statusText,
+            response: target.response,
+            responseText: responseText,
+            responseXML: responseXML,
+            headers: new Headers(this.parseHeaders(target.getAllResponseHeaders())),
+            finalUrl: target.responseURL || ""
+        };
+        try {
+            await hooker.req.response(hooker.resp);
+        } catch (error) {
+            console.warn("[AjaxInterceptor] Error in xhr response callback:", error);
+        }
+    }
+    headersEqual(a, b) {
+        if (a === b) return true;
+        const toSortedString = h => {
+            const arr = [];
+            h.forEach((v, k) => arr.push(`${k}: ${v}`));
+            return arr.sort().toString();
+        };
+        return toSortedString(a) === toSortedString(b);
+    }
+    getCaptureOption(options) {
+        if (typeof options === "boolean") return options;
+        return !!options?.capture;
+    }
+    getAttrHandler(target, attr, receiver) {
+        if (this.xhrInstanceAttr.includes(attr)) return this.xhrInstanceAttrHandler[attr](target);
+        if (this.xhrMethodsHandler[attr]) return this.xhrMethodsHandler[attr](this, target, receiver);
+        return null;
+    }
+    _generateProxyXMLHttpRequest() {
+        const self = this;
+        function proxyXhr() {
+            const xhr = new self.nativeXhr;
+            xhr[CYCLE_SCHEDULER] = new XhrCycleScheduler;
+            const proxyXhr = new Proxy(xhr, {
+                get(target, prop, receiver) {
+                    return self.getAttrHandler(target, prop, receiver) ?? getProxyValue(target, prop);
+                },
+                set(target, prop, value, receiver) {
+                    if (typeof value === "function" && prop.startsWith("on")) {
+                        const isResponseEvent = self.xhrResponseEvents.includes(prop.replace(/^on/, ""));
+                        const fn = async function(...args) {
+                            if (isResponseEvent && target.readyState === 4) await self.responseProcessor(target);
+                            Reflect.apply(value, receiver, args);
+                        };
+                        return Reflect.set(target, prop, fn);
+                    }
+                    return Reflect.set(target, prop, value);
+                }
+            });
+            return proxyXhr;
+        }
+        copyNativePropsAndPrototype({
+            source: self.nativeXhr,
+            target: proxyXhr,
+            prototype: this.nativeXhrPrototype
+        });
+        return proxyXhr;
+    }
+}
+
+class XhrCycleScheduler extends CycleScheduler {
+    xhrAlreadyReturned=false;
+    xhrOpenRestArgs=[];
+    xhrSetRequestHeadersAfterOpen=new Headers;
+    xhrWrappedEventListeners=new Map;
+    getListenerBucket(type) {
+        if (!this.xhrWrappedEventListeners.has(type)) this.xhrWrappedEventListeners.set(type, {
+            captureTrue: new WeakMap,
+            captureFalse: new WeakMap
+        });
+        return this.xhrWrappedEventListeners.get(type);
+    }
+    saveWrappedEventListener(type, capture, original, wrapped) {
+        const bucket = this.getListenerBucket(type);
+        (capture ? bucket.captureTrue : bucket.captureFalse).set(original, wrapped);
+    }
+    getWrappedEventListener(type, capture, original) {
+        const bucket = this.xhrWrappedEventListeners.get(type);
+        if (!bucket) return null;
+        return (capture ? bucket.captureTrue : bucket.captureFalse).get(original) ?? null;
+    }
+    xhrReset() {
+        this.req = {};
+        this.resp = {};
+        this.xhrOpenRestArgs = [];
+        this.xhrSetRequestHeadersAfterOpen = new Headers;
+        this.xhrAlreadyReturned = false;
+        this.xhrWrappedEventListeners.clear();
+    }
+    constructor({req: req = {}} = {}) {
+        super({
+            req: req
+        });
+    }
+}
+
+class FetchCycleScheduler extends CycleScheduler {
+    constructor({req: req = {}} = {}) {
+        super({
+            req: req
+        });
+    }
+}
+
+class FetchInterceptor {
+    nativeFetch=window.fetch;
+    nativeFetchPrototype=this.nativeFetch.prototype;
+    hooks=[];
+    fetchInstanceAttr=[ "status", "statusText", "ok", "headers", "redirected" ];
+    fetchInstanceAttrHandler=this.fetchInstanceAttr.reduce((acc, attr) => {
+        acc[attr] = function(self, target) {
+            const hooker = target[CYCLE_SCHEDULER];
+            return hooker.resp[attr];
+        };
+        return acc;
+    }, {});
+    fetchMethods=[ "json", "formData", "blob", "arrayBuffer", "text" ];
+    fetchMethodsHandler=this.fetchMethods.reduce((acc, methodName) => {
+        acc[methodName] = function(self, target) {
+            return async function(...args) {
+                const hooker = target[CYCLE_SCHEDULER];
+                return hooker.resp[methodName];
+            };
+        };
+        return acc;
+    }, {});
+    constructor() {}
+    inject() {
+        window.fetch = this._generateProxyFetch();
+    }
+    uninject() {
+        window.fetch = this.nativeFetch;
+    }
+    getAttrHandler(target, attr) {
+        if (this.fetchInstanceAttr.includes(attr)) return this.fetchInstanceAttrHandler[attr](this, target);
+        if (this.fetchMethodsHandler[attr]) return this.fetchMethodsHandler[attr](this, target);
+        return null;
+    }
+    normalizeRequest(req) {
+        let url = "";
+        let method = null;
+        let headers = null;
+        let data = null;
+        if (typeof req === "string") url = resolveUrl(req); else if (req instanceof URL) url = resolveUrl(req); else {
+            url = resolveUrl(req.url);
+            method = req.method ?? null;
+            headers = req.headers ?? null;
+            data = req.body ?? null;
+        }
+        return {
+            url: url,
+            method: method,
+            headers: headers,
+            data: data
+        };
+    }
+    resolveRequest(req, newRequest, sourceMap) {
+        const urlChanged = typeof req === "string" && newRequest.url !== req || req instanceof URL && newRequest.url !== req.href || req instanceof Request && newRequest.url !== req.url;
+        if (typeof req === "string") return urlChanged ? newRequest.url : req;
+        if (req instanceof URL) return urlChanged ? new URL(newRequest.url) : req;
+        if (req instanceof Request) {
+            const needsNewRequest = urlChanged || sourceMap.method === "request" && newRequest.method !== req.method || sourceMap.headers === "request" && newRequest.headers !== req.headers || sourceMap.data === "request" && newRequest.data !== req.body;
+            if (needsNewRequest) {
+                const methodChanged = sourceMap.method === "request" && newRequest.method !== req.method;
+                const headersChanged = sourceMap.headers === "request" && newRequest.headers !== req.headers;
+                const bodyChanged = sourceMap.data === "request" && newRequest.data !== req.body;
+                return new Request(urlChanged ? newRequest.url : req, {
+                    ...methodChanged && {
+                        method: newRequest.method
+                    },
+                    ...headersChanged && {
+                        headers: newRequest.headers
+                    },
+                    ...bodyChanged && {
+                        body: newRequest.data
+                    }
+                });
+            }
+            return req;
+        }
+        return req;
+    }
+    resolveOptions({options: options, newRequest: newRequest, sourceMap: sourceMap}) {
+        const {method: _, headers: __, body: ___, ...rest} = options || {};
+        const resolved = {
+            ...rest
+        };
+        if (sourceMap.method === "options" || sourceMap.method === "default" && newRequest.method !== (options?.method ?? "GET")) resolved.method = newRequest.method;
+        if (sourceMap.headers === "options") resolved.headers = newRequest.headers; else if (sourceMap.headers === "default") {
+            let isHeadersEmpty = true;
+            if (newRequest.headers instanceof Headers) {
+                let count = 0;
+                newRequest.headers.forEach(() => {
+                    count++;
+                });
+                isHeadersEmpty = count === 0;
+            } else if (newRequest.headers) isHeadersEmpty = Object.keys(newRequest.headers).length === 0;
+            if (!isHeadersEmpty) resolved.headers = newRequest.headers;
+        }
+        if (sourceMap.data === "options" || sourceMap.data === "default" && newRequest.data !== (options?.body ?? null)) resolved.body = newRequest.data;
+        if (newRequest.data instanceof ReadableStream) resolved.duplex = "half";
+        return resolved;
+    }
+    resolveHeaders(headers) {
+        if (headers instanceof Headers) return headers;
+        return new Headers(headers);
+    }
+    _generateProxyFetch() {
+        const self = this;
+        async function proxyFetch(req, options = {}) {
+            const request = self.normalizeRequest(req);
+            const winFetch = self.nativeFetch;
+            const hooker = new FetchCycleScheduler;
+            const sourceMap = {
+                method: "default",
+                headers: "default",
+                data: "default"
+            };
+            if (req instanceof Request) {
+                sourceMap.method = "request";
+                sourceMap.headers = "request";
+                if (req.body !== null) sourceMap.data = "request";
+            }
+            if (options.method !== void 0) sourceMap.method = "options";
+            if (options.headers !== void 0) sourceMap.headers = "options";
+            if (options.body !== void 0) sourceMap.data = "options";
+            const originalRequest = {
+                type: AJAX_TYPE.FETCH,
+                url: request.url,
+                method: options.method ?? request.method ?? "GET",
+                headers: self.resolveHeaders(options.headers ?? request.headers ?? new Headers),
+                data: options.body ?? request.data ?? null,
+                response: () => {}
+            };
+            let newRequest = originalRequest;
+            try {
+                newRequest = await hooker.execute(originalRequest, self.hooks);
+            } catch (error) {
+                console.warn("[AjaxInterceptor] Error in fetch request hooks:", error);
+            }
+            hooker.req = newRequest;
+            const fh = await winFetch(self.resolveRequest(req, newRequest, sourceMap), self.resolveOptions({
+                options: options,
+                newRequest: newRequest,
+                sourceMap: sourceMap
+            }));
+            const contentType = fh.headers.get("content-type") || "";
+            const isStreamResponse = contentType.includes("text/event-stream") || contentType.includes("application/stream+json") || contentType.includes("application/x-ndjson") || contentType.includes("application/jsonl") || contentType.includes("application/json-seq");
+            let interceptedResponse = fh;
+            if (isStreamResponse && fh.body) {
+                hooker.resp = {
+                    status: fh.status,
+                    statusText: fh.statusText,
+                    ok: fh.ok,
+                    headers: fh.headers,
+                    finalUrl: fh.url,
+                    redirected: fh.redirected
+                };
+                try {
+                    await hooker.req.response(hooker.resp);
+                } catch (error) {
+                    console.warn("[AjaxInterceptor] Error in fetch stream response callback:", error);
+                }
+                let chunkIndex = 0;
+                const {readable: readable, writable: writable} = new TransformStream({
+                    async transform(chunk, controller) {
+                        try {
+                            const decoder = new TextDecoder;
+                            const text = decoder.decode(chunk, {
+                                stream: true
+                            });
+                            let modifiedText = text;
+                            if (hooker.req.onStreamChunk) {
+                                const streamChunk = {
+                                    text: text,
+                                    raw: chunk,
+                                    index: chunkIndex++,
+                                    timestamp: Date.now()
+                                };
+                                const result = await hooker.req.onStreamChunk(streamChunk);
+                                if (typeof result === "string") modifiedText = result;
+                            }
+                            const encoder = new TextEncoder;
+                            controller.enqueue(encoder.encode(modifiedText));
+                        } catch (error) {
+                            controller.enqueue(chunk);
+                        }
+                    }
+                });
+                fh.body.pipeTo(writable);
+                interceptedResponse = new Response(readable, {
+                    status: fh.status,
+                    statusText: fh.statusText,
+                    headers: fh.headers
+                });
+            } else if (!isStreamResponse) {
+                const [json, text, arrayBuffer, blob, formData] = await Promise.allSettled([ fh.clone().json(), fh.clone().text(), fh.clone().arrayBuffer(), fh.clone().blob(), fh.clone().formData() ]).then(results => results.map(result => result.status === "fulfilled" ? result.value : null));
+                hooker.resp = {
+                    status: fh.status,
+                    statusText: fh.statusText,
+                    ok: fh.ok,
+                    headers: fh.headers,
+                    finalUrl: fh.url,
+                    redirected: fh.redirected,
+                    json: json,
+                    text: text,
+                    arrayBuffer: arrayBuffer,
+                    blob: blob,
+                    formData: formData
+                };
+                try {
+                    await hooker.req.response(hooker.resp);
+                } catch (error) {
+                    console.warn("[AjaxInterceptor] Error in fetch response callback:", error);
+                }
+            }
+            interceptedResponse[CYCLE_SCHEDULER] = hooker;
+            const proxyFh = new Proxy(interceptedResponse, {
+                get(target, prop) {
+                    const attrHandler = self.getAttrHandler(target, prop);
+                    if (attrHandler) return attrHandler;
+                    return getProxyValue(target, prop);
+                },
+                set(target, prop, value) {
+                    return Reflect.set(target, prop, value);
+                }
+            });
+            return proxyFh;
+        }
+        copyNativePropsAndPrototype({
+            source: this.nativeFetch,
+            target: proxyFetch,
+            prototype: this.nativeFetchPrototype
+        });
+        return proxyFetch;
+    }
+}
+
+class AjaxInterceptor {
+    xhrInterceptor;
+    fetchInterceptor;
+    static #instance;
+    static #token=Symbol("AjaxInterceptor");
+    static getInstance(options = {}) {
+        if (!AjaxInterceptor.#instance) AjaxInterceptor.#instance = new AjaxInterceptor(AjaxInterceptor.#token, options);
+        return AjaxInterceptor.#instance;
+    }
+    constructor(token, options = {}) {
+        if (token !== AjaxInterceptor.#token) throw new Error("AjaxInterceptor is a singleton");
+        this.xhrInterceptor = new XhrInterceptor;
+        this.fetchInterceptor = new FetchInterceptor;
+    }
+    toggleInject(type, action) {
+        switch (type) {
+          case AJAX_TYPE.XHR:
+            this.xhrInterceptor[action]();
+            break;
+
+          case AJAX_TYPE.FETCH:
+            this.fetchInterceptor[action]();
+            break;
+
+          default:
+            this.xhrInterceptor[action]();
+            this.fetchInterceptor[action]();
+            break;
+        }
+    }
+    inject(type) {
+        if (typeof window === "undefined") throw new Error("AjaxInterceptor requires a browser environment");
+        if (!window.XMLHttpRequest) console.warn("XMLHttpRequest is not supported in this environment");
+        if (!window.fetch) console.warn("Fetch API is not supported in this environment");
+        this.toggleInject(type, "inject");
+    }
+    uninject(type) {
+        this.toggleInject(type, "uninject");
+    }
+    hook(fn, type) {
+        switch (type) {
+          case AJAX_TYPE.XHR:
+            this.xhrInterceptor.hooks.push(fn);
+            break;
+
+          case AJAX_TYPE.FETCH:
+            this.fetchInterceptor.hooks.push(fn);
+            break;
+
+          default:
+            this.xhrInterceptor.hooks.push(fn);
+            this.fetchInterceptor.hooks.push(fn);
+            break;
+        }
+    }
+    unhook(fn, type) {
+        const removeFrom = hooks => {
+            if (!fn) {
+                hooks.length = 0;
+                return;
+            }
+            const index = hooks.indexOf(fn);
+            if (index !== -1) hooks.splice(index, 1);
+        };
+        switch (type) {
+          case AJAX_TYPE.XHR:
+            removeFrom(this.xhrInterceptor.hooks);
+            break;
+
+          case AJAX_TYPE.FETCH:
+            removeFrom(this.fetchInterceptor.hooks);
+            break;
+
+          default:
+            removeFrom(this.xhrInterceptor.hooks);
+            removeFrom(this.fetchInterceptor.hooks);
+            break;
+        }
+    }
+}
+
+export { AjaxInterceptor, AjaxInterceptor as default };