ajax-hooker 1.2.0 → 1.2.2

package/dist/iife/index.js

@@ -1 +1,610 @@
-var ajaxInterceptor=function(e){"use strict";const t="xhr",r="fetch",s=Symbol("CycleScheduler");class n{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 o=Object.prototype.toString.call.bind(Object.prototype.toString),a=(e="")=>new URL(e,window.location.origin).toString(),c=(e,t)=>{const r=Reflect.get(e,t);return"function"!=typeof r?r:function(...t){return Reflect.apply(r,e,t)}},h=({source:e,target:t,prototype:r})=>{Object.keys(e).forEach(r=>{t[r]=e[r]}),t.prototype=r};class i{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 r=e[s];return r.xhrAlreadyReturned?r.resp[t]:e[t]},e),{});xhrMethodsHandler={open:function(e,r){return function(...n){const o=r[s];o.xhrReset(),o.req={type:t,method:n[0]||"GET",url:a(n[1]),headers:new Headers,data:null,response:()=>{}},o.xhrOpenRestArgs=n.slice(2),e.nativeXhrPrototype.open.apply(r,[o.req.method,o.req.url,...o.xhrOpenRestArgs||[]])}},send:function(e,t){return async function(r){const n=t[s];n.req.data=r??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(r,n){const o=t[s];e.nativeXhrPrototype.setRequestHeader.apply(t,[r,n]),o.xhrSetRequestHeadersAfterOpen.append(r,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=o(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[s];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[s]=new d;return new Proxy(t,{get:(t,r,s)=>e.getAttrHandler(t,r,s)??c(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 h({source:e.nativeXhr,target:t,prototype:this.nativeXhrPrototype}),t}}class d extends n{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 u extends n{constructor({req:e={}}={}){super({req:e})}}class l{nativeFetch=window.fetch;nativeFetchPrototype=this.nativeFetch.prototype;hooks=[];fetchInstanceAttr=["status","statusText","ok","headers","redirected"];fetchInstanceAttrHandler=this.fetchInstanceAttr.reduce((e,t)=>(e[t]=function(e,r){return r[s].resp[t]},e),{});fetchMethods=["json","formData","blob","arrayBuffer","text"];fetchMethodsHandler=this.fetchMethods.reduce((e,t)=>(e[t]=function(e,r){return async function(...e){return r[s].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=a(e):(t=a(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 t(t,n={}){const o=e.normalizeRequest(t),a=e.nativeFetch,h=new u,i={method:"default",headers:"default",data:"default"};t instanceof Request&&(i.method="request",i.headers="request",null!==t.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 d={type:r,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=d;try{l=await h.execute(d,e.hooks)}catch(e){console.warn("[AjaxInterceptor] Error in fetch request hooks:",e)}h.req=l;const p=await a(e.resolveRequest(t,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 x=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),x=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)}}x[s]=h;return new Proxy(x,{get(t,r){const s=e.getAttrHandler(t,r);return s||c(t,r)},set:(e,t,r)=>Reflect.set(e,t,r)})}return h({source:this.nativeFetch,target:t,prototype:this.nativeFetchPrototype}),t}}class p{xhrInterceptor;fetchInterceptor;static#e;static#t=Symbol("AjaxInterceptor");static getInstance(e={}){return p.#e||(p.#e=new p(p.#t,e)),p.#e}constructor(e,t={}){if(e!==p.#t)throw new Error("AjaxInterceptor is a singleton");this.xhrInterceptor=new i,this.fetchInterceptor=new l}toggleInject(e,s){switch(e){case t:this.xhrInterceptor[s]();break;case r: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(e,s){switch(s){case t:this.xhrInterceptor.hooks.push(e);break;case r:this.fetchInterceptor.hooks.push(e);break;default:this.xhrInterceptor.hooks.push(e),this.fetchInterceptor.hooks.push(e)}}unhook(e,s){const n=t=>{if(!e)return void(t.length=0);const r=t.indexOf(e);-1!==r&&t.splice(r,1)};switch(s){case t:n(this.xhrInterceptor.hooks);break;case r:n(this.fetchInterceptor.hooks);break;default:n(this.xhrInterceptor.hooks),n(this.fetchInterceptor.hooks)}}}return e.AjaxInterceptor=p,e.default=p,Object.defineProperty(e,"__esModule",{value:!0}),e}({});
+var AjaxHooker = function(exports) {
+    "use strict";
+    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;
+            }
+        }
+    }
+    exports.AjaxInterceptor = AjaxInterceptor;
+    exports.default = AjaxInterceptor;
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    return exports;
+}({});
+
+AjaxHooker = Object.assign(AjaxHooker.default || AjaxHooker, AjaxHooker);

package/dist/types/interceptor.d.ts

@@ -4,13 +4,17 @@ import { FetchInterceptor } from './fetch';
 declare class AjaxInterceptor {
     #private;
     /**
-     * @deprecated Direct access to internal interceptor instances is kept only for 1.x compatibility.
-     * Use `hook` / `unhook` / `inject` / `uninject` instead. Planned to become private in 2.x.
+     * 1.x compatibility field.
+     * Direct access to internal instances is still available in 1.x,
+     * and is planned to become private in 2.x.
+     * Prefer `hook` / `unhook` / `inject` / `uninject`.
      */
     xhrInterceptor: XhrInterceptor;
     /**
-     * @deprecated Direct access to internal interceptor instances is kept only for 1.x compatibility.
-     * Use `hook` / `unhook` / `inject` / `uninject` instead. Planned to become private in 2.x.
+     * 1.x compatibility field.
+     * Direct access to internal instances is still available in 1.x,
+     * and is planned to become private in 2.x.
+     * Prefer `hook` / `unhook` / `inject` / `uninject`.
      */
     fetchInterceptor: FetchInterceptor;
     static getInstance(options?: AjaxInterceptorCreateInstanceOptions): AjaxInterceptor;

package/dist/types/xhr.d.ts

@@ -21,6 +21,7 @@ export declare class XhrInterceptor {
     private parseHeaders;
     private responseProcessor;
     private headersEqual;
+    private getCaptureOption;
     private getAttrHandler;
     private _generateProxyXMLHttpRequest;
 }