@whitesev/utils 2.9.3 → 2.9.5

package/dist/index.system.js

@@ -6,7 +6,7 @@ System.register('Utils', [], (function (exports) {
             class ColorConversion {
                 /**
                  * 判断是否是16进制颜色
-                 * @param str
+                 * @param str 十六进制颜色，如`#000000`
                  */
                 isHex(str) {
                     if (typeof str !== "string") {
@@ -21,8 +21,8 @@ System.register('Utils', [], (function (exports) {
                  * 16进制颜色转rgba
                  *
                  * 例如：`#ff0000` 转为 `rgba(123,123,123, 0.4)`
-                 * @param hex
-                 * @param opacity
+                 * @param hex 十六进制颜色，如`#000000`
+                 * @param opacity 透明度，0~1
                  */
                 hexToRgba(hex, opacity) {
                     if (!this.isHex(hex)) {
@@ -34,16 +34,16 @@ System.register('Utils', [], (function (exports) {
                 }
                 /**
                  * hex转rgb
-                 * @param str
+                 * @param hex 十六进制颜色，如`#000000`
                  */
-                hexToRgb(str) {
-                    if (!this.isHex(str)) {
-                        throw new TypeError(`输入错误的hex：${str}`);
+                hexToRgb(hex) {
+                    if (!this.isHex(hex)) {
+                        throw new TypeError(`输入错误的hex：${hex}`);
                     }
                     /* replace替换查找的到的字符串 */
-                    str = str.replace("#", "");
+                    hex = hex.replace("#", "");
                     /* match得到查询数组 */
-                    const hxs = str.match(/../g);
+                    const hxs = hex.match(/../g);
                     for (let index = 0; index < 3; index++) {
                         const value = parseInt(hxs[index], 16);
                         Reflect.set(hxs, index, value);
@@ -52,9 +52,10 @@ System.register('Utils', [], (function (exports) {
                 }
                 /**
                  * rgb转hex
-                 * @param redValue
-                 * @param greenValue
-                 * @param blueValue
+                 * @param redValue 红色值
+                 * @param greenValue 绿色值
+                 * @param blueValue 蓝色值
+                 * @returns hex
                  */
                 rgbToHex(redValue, greenValue, blueValue) {
                     /* 验证输入的rgb值是否合法 */
@@ -71,30 +72,36 @@ System.register('Utils', [], (function (exports) {
                 }
                 /**
                  * 获取颜色变暗或亮
-                 * @param color 颜色
-                 * @param level 0~1.0
+                 * @param color hex颜色，如`#000000`
+                 * @param level 0~1.0 系数越大，颜色越变暗
                  */
                 getDarkColor(color, level) {
                     if (!this.isHex(color)) {
                         throw new TypeError(`输入错误的hex：${color}`);
                     }
+                    if (typeof level !== "number") {
+                        level = Number(level);
+                    }
                     const rgbc = this.hexToRgb(color);
                     for (let index = 0; index < 3; index++) {
                         const rgbcItemValue = rgbc[index];
-                        const value = Math.floor(Number(rgbcItemValue) * (1 - Number(level)));
+                        const value = Math.floor(Number(rgbcItemValue) * (1 - level));
                         Reflect.set(rgbc, index, value);
                     }
                     return this.rgbToHex(rgbc[0], rgbc[1], rgbc[2]);
                 }
                 /**
                  * 获取颜色变亮
-                 * @param color 颜色
-                 * @param level 0~1.0
+                 * @param color hex颜色，如`#000000`
+                 * @param level 0~1.0 系数越大，颜色越变亮
                  */
                 getLightColor(color, level) {
                     if (!this.isHex(color)) {
                         throw new TypeError(`输入错误的hex：${color}`);
                     }
+                    if (typeof level !== "number") {
+                        level = Number(level);
+                    }
                     const rgbc = this.hexToRgb(color);
                     for (let index = 0; index < 3; index++) {
                         const rgbcItemValue = Number(rgbc[index]);
@@ -716,1001 +723,981 @@ System.register('Utils', [], (function (exports) {
                 }
             }
 
-            /* eslint-disable */
-            // ==UserScript==
-            // @name         ajaxHooker
-            // @author       cxxjackie
-            // @version      1.4.8
-            // @supportURL   https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
-            // @license      GNU LGPL-3.0
-            // ==/UserScript==
-
-            const ajaxHooker = function () {
-            	const version = "1.4.8";
-            	const hookInst = {
-            		hookFns: [],
-            		filters: [],
-            	};
-            	const win = window.unsafeWindow || document.defaultView || window;
-            	let winAh = win.__ajaxHooker;
-            	const resProto = win.Response.prototype;
-            	const xhrResponses = ["response", "responseText", "responseXML"];
-            	const fetchResponses = ["arrayBuffer", "blob", "formData", "json", "text"];
-            	const xhrExtraProps = ["responseType", "timeout", "withCredentials"];
-            	const fetchExtraProps = [
-            		"cache",
-            		"credentials",
-            		"integrity",
-            		"keepalive",
-            		"mode",
-            		"priority",
-            		"redirect",
-            		"referrer",
-            		"referrerPolicy",
-            		"signal",
-            	];
-            	const xhrAsyncEvents = ["readystatechange", "load", "loadend"];
-            	const getType = {}.toString.call.bind({}.toString);
-            	const getDescriptor = Object.getOwnPropertyDescriptor.bind(Object);
-            	const emptyFn = () => {};
-            	const errorFn = (e) => console.error(e);
-            	function isThenable(obj) {
-            		return obj && ["object", "function"].includes(typeof obj) && typeof obj.then === "function";
-            	}
-            	function catchError(fn, ...args) {
-            		try {
-            			const result = fn(...args);
-            			if (isThenable(result)) return result.then(null, errorFn);
-            			return result;
-            		} catch (err) {
-            			console.error(err);
-            		}
-            	}
-            	function defineProp(obj, prop, getter, setter) {
-            		Object.defineProperty(obj, prop, {
-            			configurable: true,
-            			enumerable: true,
-            			get: getter,
-            			set: setter,
-            		});
-            	}
-            	function readonly(obj, prop, value = obj[prop]) {
-            		defineProp(obj, prop, () => value, emptyFn);
-            	}
-            	function writable(obj, prop, value = obj[prop]) {
-            		Object.defineProperty(obj, prop, {
-            			configurable: true,
-            			enumerable: true,
-            			writable: true,
-            			value: value,
-            		});
-            	}
-            	function parseHeaders(obj) {
-            		const headers = {};
-            		switch (getType(obj)) {
-            			case "[object String]":
-            				for (const line of obj.trim().split(/[\r\n]+/)) {
-            					const [header, value] = line.split(/(?<=^[^:]+)\s*:\s*/);
-            					if (!value) continue;
-            					const lheader = header.toLowerCase();
-            					headers[lheader] = lheader in headers ? `${headers[lheader]}, ${value}` : value;
-            				}
-            				break;
-            			case "[object Headers]":
-            				for (const [key, val] of obj) {
-            					headers[key] = val;
-            				}
-            				break;
-            			case "[object Object]":
-            				return { ...obj };
-            		}
-            		return headers;
-            	}
-            	function stopImmediatePropagation() {
-            		this.ajaxHooker_isStopped = true;
-            	}
-            	class SyncThenable {
-            		then(fn) {
-            			fn && fn();
-            			return new SyncThenable();
-            		}
-            	}
-            	class AHRequest {
-            		constructor(request) {
-            			this.request = request;
-            			this.requestClone = { ...this.request };
-            		}
-            		_recoverRequestKey(key) {
-            			if (key in this.requestClone) this.request[key] = this.requestClone[key];
-            			else delete this.request[key];
-            		}
-            		shouldFilter(filters) {
-            			const { type, url, method, async } = this.request;
-            			return (
-            				filters.length &&
-            				!filters.find((obj) => {
-            					switch (true) {
-            						case obj.type && obj.type !== type:
-            						case getType(obj.url) === "[object String]" && !url.includes(obj.url):
-            						case getType(obj.url) === "[object RegExp]" && !obj.url.test(url):
-            						case obj.method && obj.method.toUpperCase() !== method.toUpperCase():
-            						case "async" in obj && obj.async !== async:
-            							return false;
-            					}
-            					return true;
-            				})
-            			);
-            		}
-            		waitForRequestKeys() {
-            			if (!this.request.async) {
-            				win.__ajaxHooker.hookInsts.forEach(({ hookFns, filters }) => {
-            					if (this.shouldFilter(filters)) return;
-            					hookFns.forEach((fn) => {
-            						if (getType(fn) === "[object Function]") catchError(fn, this.request);
-            					});
-            					for (const key in this.request) {
-            						if (isThenable(this.request[key])) this._recoverRequestKey(key);
-            					}
-            				});
-            				return new SyncThenable();
-            			}
-            			const promises = [];
-            			const ignoreKeys = new Set(["type", "async", "response"]);
-            			win.__ajaxHooker.hookInsts.forEach(({ hookFns, filters }) => {
-            				if (this.shouldFilter(filters)) return;
-            				promises.push(
-            					Promise.all(hookFns.map((fn) => catchError(fn, this.request))).then(() => {
-            						const requestKeys = [];
-            						for (const key in this.request) !ignoreKeys.has(key) && requestKeys.push(key);
-            						return Promise.all(
-            							requestKeys.map((key) =>
-            								Promise.resolve(this.request[key]).then(
-            									(val) => (this.request[key] = val),
-            									() => this._recoverRequestKey(key)
-            								)
-            							)
-            						);
-            					})
-            				);
-            			});
-            			return Promise.all(promises);
-            		}
-            		waitForResponseKeys(response) {
-            			const responseKeys = this.request.type === "xhr" ? xhrResponses : fetchResponses;
-            			if (!this.request.async) {
-            				if (getType(this.request.response) === "[object Function]") {
-            					catchError(this.request.response, response);
-            					responseKeys.forEach((key) => {
-            						if ("get" in getDescriptor(response, key) || isThenable(response[key])) {
-            							delete response[key];
-            						}
-            					});
-            				}
-            				return new SyncThenable();
-            			}
-            			return Promise.resolve(catchError(this.request.response, response)).then(() =>
-            				Promise.all(
-            					responseKeys.map((key) => {
-            						const descriptor = getDescriptor(response, key);
-            						if (descriptor && "value" in descriptor) {
-            							return Promise.resolve(descriptor.value).then(
-            								(val) => (response[key] = val),
-            								() => delete response[key]
-            							);
-            						} else {
-            							delete response[key];
-            						}
-            					})
-            				)
-            			);
-            		}
-            	}
-            	const proxyHandler = {
-            		get(target, prop) {
-            			const descriptor = getDescriptor(target, prop);
-            			if (descriptor && !descriptor.configurable && !descriptor.writable && !descriptor.get)
-            				return target[prop];
-            			const ah = target.__ajaxHooker;
-            			if (ah && ah.proxyProps) {
-            				if (prop in ah.proxyProps) {
-            					const pDescriptor = ah.proxyProps[prop];
-            					if ("get" in pDescriptor) return pDescriptor.get();
-            					if (typeof pDescriptor.value === "function") return pDescriptor.value.bind(ah);
-            					return pDescriptor.value;
-            				}
-            				if (typeof target[prop] === "function") return target[prop].bind(target);
-            			}
-            			return target[prop];
-            		},
-            		set(target, prop, value) {
-            			const descriptor = getDescriptor(target, prop);
-            			if (descriptor && !descriptor.configurable && !descriptor.writable && !descriptor.set) return true;
-            			const ah = target.__ajaxHooker;
-            			if (ah && ah.proxyProps && prop in ah.proxyProps) {
-            				const pDescriptor = ah.proxyProps[prop];
-            				pDescriptor.set ? pDescriptor.set(value) : (pDescriptor.value = value);
-            			} else {
-            				target[prop] = value;
-            			}
-            			return true;
-            		},
-            	};
-            	class XhrHooker {
-            		constructor(xhr) {
-            			const ah = this;
-            			Object.assign(ah, {
-            				originalXhr: xhr,
-            				proxyXhr: new Proxy(xhr, proxyHandler),
-            				resThenable: new SyncThenable(),
-            				proxyProps: {},
-            				proxyEvents: {},
-            			});
-            			xhr.addEventListener("readystatechange", (e) => {
-            				if (ah.proxyXhr.readyState === 4 && ah.request && typeof ah.request.response === "function") {
-            					const response = {
-            						finalUrl: ah.proxyXhr.responseURL,
-            						status: ah.proxyXhr.status,
-            						responseHeaders: parseHeaders(ah.proxyXhr.getAllResponseHeaders()),
-            					};
-            					const tempValues = {};
-            					for (const key of xhrResponses) {
-            						try {
-            							tempValues[key] = ah.originalXhr[key];
-            						} catch (err) {}
-            						defineProp(
-            							response,
-            							key,
-            							() => {
-            								return (response[key] = tempValues[key]);
-            							},
-            							(val) => {
-            								delete response[key];
-            								response[key] = val;
-            							}
-            						);
-            					}
-            					ah.resThenable = new AHRequest(ah.request).waitForResponseKeys(response).then(() => {
-            						for (const key of xhrResponses) {
-            							ah.proxyProps[key] = {
-            								get: () => {
-            									if (!(key in response)) response[key] = tempValues[key];
-            									return response[key];
-            								},
-            							};
-            						}
-            					});
-            				}
-            				ah.dispatchEvent(e);
-            			});
-            			xhr.addEventListener("load", (e) => ah.dispatchEvent(e));
-            			xhr.addEventListener("loadend", (e) => ah.dispatchEvent(e));
-            			for (const evt of xhrAsyncEvents) {
-            				const onEvt = "on" + evt;
-            				ah.proxyProps[onEvt] = {
-            					get: () => ah.proxyEvents[onEvt] || null,
-            					set: (val) => ah.addEvent(onEvt, val),
-            				};
-            			}
-            			for (const method of ["setRequestHeader", "addEventListener", "removeEventListener", "open", "send"]) {
-            				ah.proxyProps[method] = { value: ah[method] };
-            			}
-            		}
-            		toJSON() {} // Converting circular structure to JSON
-            		addEvent(type, event) {
-            			if (type.startsWith("on")) {
-            				this.proxyEvents[type] = typeof event === "function" ? event : null;
-            			} else {
-            				if (typeof event === "object" && event !== null) event = event.handleEvent;
-            				if (typeof event !== "function") return;
-            				this.proxyEvents[type] = this.proxyEvents[type] || new Set();
-            				this.proxyEvents[type].add(event);
-            			}
-            		}
-            		removeEvent(type, event) {
-            			if (type.startsWith("on")) {
-            				this.proxyEvents[type] = null;
-            			} else {
-            				if (typeof event === "object" && event !== null) event = event.handleEvent;
-            				this.proxyEvents[type] && this.proxyEvents[type].delete(event);
-            			}
-            		}
-            		dispatchEvent(e) {
-            			e.stopImmediatePropagation = stopImmediatePropagation;
-            			defineProp(e, "target", () => this.proxyXhr);
-            			defineProp(e, "currentTarget", () => this.proxyXhr);
-            			defineProp(e, "srcElement", () => this.proxyXhr);
-            			this.proxyEvents[e.type] &&
-            				this.proxyEvents[e.type].forEach((fn) => {
-            					this.resThenable.then(() => !e.ajaxHooker_isStopped && fn.call(this.proxyXhr, e));
-            				});
-            			if (e.ajaxHooker_isStopped) return;
-            			const onEvent = this.proxyEvents["on" + e.type];
-            			onEvent && this.resThenable.then(onEvent.bind(this.proxyXhr, e));
-            		}
-            		setRequestHeader(header, value) {
-            			this.originalXhr.setRequestHeader(header, value);
-            			if (!this.request) return;
-            			const headers = this.request.headers;
-            			headers[header] = header in headers ? `${headers[header]}, ${value}` : value;
-            		}
-            		addEventListener(...args) {
-            			if (xhrAsyncEvents.includes(args[0])) {
-            				this.addEvent(args[0], args[1]);
-            			} else {
-            				this.originalXhr.addEventListener(...args);
-            			}
-            		}
-            		removeEventListener(...args) {
-            			if (xhrAsyncEvents.includes(args[0])) {
-            				this.removeEvent(args[0], args[1]);
-            			} else {
-            				this.originalXhr.removeEventListener(...args);
-            			}
-            		}
-            		open(method, url, async = true, ...args) {
-            			this.request = {
-            				type: "xhr",
-            				url: url.toString(),
-            				method: method.toUpperCase(),
-            				abort: false,
-            				headers: {},
-            				data: null,
-            				response: null,
-            				async: !!async,
-            			};
-            			this.openArgs = args;
-            			this.resThenable = new SyncThenable();
-            			["responseURL", "readyState", "status", "statusText", ...xhrResponses].forEach((key) => {
-            				delete this.proxyProps[key];
-            			});
-            			return this.originalXhr.open(method, url, async, ...args);
-            		}
-            		send(data) {
-            			const ah = this;
-            			const xhr = ah.originalXhr;
-            			const request = ah.request;
-            			if (!request) return xhr.send(data);
-            			request.data = data;
-            			new AHRequest(request).waitForRequestKeys().then(() => {
-            				if (request.abort) {
-            					if (typeof request.response === "function") {
-            						Object.assign(ah.proxyProps, {
-            							responseURL: { value: request.url },
-            							readyState: { value: 4 },
-            							status: { value: 200 },
-            							statusText: { value: "OK" },
-            						});
-            						xhrAsyncEvents.forEach((evt) => xhr.dispatchEvent(new Event(evt)));
-            					}
-            				} else {
-            					xhr.open(request.method, request.url, request.async, ...ah.openArgs);
-            					for (const header in request.headers) {
-            						xhr.setRequestHeader(header, request.headers[header]);
-            					}
-            					for (const prop of xhrExtraProps) {
-            						if (prop in request) xhr[prop] = request[prop];
-            					}
-            					xhr.send(request.data);
-            				}
-            			});
-            		}
-            	}
-            	function fakeXHR() {
-            		const xhr = new winAh.realXHR();
-            		if ("__ajaxHooker" in xhr) console.warn("检测到不同版本的ajaxHooker，可能发生冲突！");
-            		xhr.__ajaxHooker = new XhrHooker(xhr);
-            		return xhr.__ajaxHooker.proxyXhr;
-            	}
-            	fakeXHR.prototype = win.XMLHttpRequest.prototype;
-            	Object.keys(win.XMLHttpRequest).forEach((key) => (fakeXHR[key] = win.XMLHttpRequest[key]));
-            	function fakeFetch(url, options = {}) {
-            		if (!url) return winAh.realFetch.call(win, url, options);
-            		return new Promise(async (resolve, reject) => {
-            			const init = {};
-            			if (getType(url) === "[object Request]") {
-            				init.method = url.method;
-            				init.headers = url.headers;
-            				if (url.body) init.body = await url.arrayBuffer();
-            				for (const prop of fetchExtraProps) init[prop] = url[prop];
-            				url = url.url;
-            			}
-            			url = url.toString();
-            			Object.assign(init, options);
-            			init.method = init.method || "GET";
-            			init.headers = init.headers || {};
-            			const request = {
-            				type: "fetch",
-            				url: url,
-            				method: init.method.toUpperCase(),
-            				abort: false,
-            				headers: parseHeaders(init.headers),
-            				data: init.body,
-            				response: null,
-            				async: true,
-            			};
-            			const req = new AHRequest(request);
-            			await req.waitForRequestKeys();
-            			if (request.abort) {
-            				if (typeof request.response === "function") {
-            					const response = {
-            						finalUrl: request.url,
-            						status: 200,
-            						responseHeaders: {},
-            					};
-            					await req.waitForResponseKeys(response);
-            					const key = fetchResponses.find((k) => k in response);
-            					let val = response[key];
-            					if (key === "json" && typeof val === "object") {
-            						val = catchError(JSON.stringify.bind(JSON), val);
-            					}
-            					const res = new Response(val, {
-            						status: 200,
-            						statusText: "OK",
-            					});
-            					defineProp(res, "type", () => "basic");
-            					defineProp(res, "url", () => request.url);
-            					resolve(res);
-            				} else {
-            					reject(new DOMException("aborted", "AbortError"));
-            				}
-            				return;
-            			}
-            			init.method = request.method;
-            			init.headers = request.headers;
-            			init.body = request.data;
-            			for (const prop of fetchExtraProps) {
-            				if (prop in request) init[prop] = request[prop];
-            			}
-            			winAh.realFetch.call(win, request.url, init).then((res) => {
-            				if (typeof request.response === "function") {
-            					const response = {
-            						finalUrl: res.url,
-            						status: res.status,
-            						responseHeaders: parseHeaders(res.headers),
-            					};
-            					if (res.ok) {
-            						fetchResponses.forEach(
-            							(key) =>
-            								(res[key] = function () {
-            									if (key in response) return Promise.resolve(response[key]);
-            									return resProto[key].call(this).then((val) => {
-            										response[key] = val;
-            										return req
-            											.waitForResponseKeys(response)
-            											.then(() => (key in response ? response[key] : val));
-            									});
-            								})
-            						);
-            					} else {
-            						catchError(request.response, response);
-            					}
-            				}
-            				resolve(res);
-            			}, reject);
-            		});
-            	}
-            	function fakeFetchClone() {
-            		const descriptors = Object.getOwnPropertyDescriptors(this);
-            		const res = winAh.realFetchClone.call(this);
-            		Object.defineProperties(res, descriptors);
-            		return res;
-            	}
-            	winAh = win.__ajaxHooker = winAh || {
-            		version,
-            		fakeXHR,
-            		fakeFetch,
-            		fakeFetchClone,
-            		realXHR: win.XMLHttpRequest,
-            		realFetch: win.fetch,
-            		realFetchClone: resProto.clone,
-            		hookInsts: new Set(),
-            	};
-            	if (winAh.version !== version) console.warn("检测到不同版本的ajaxHooker，可能发生冲突！");
-            	win.XMLHttpRequest = winAh.fakeXHR;
-            	win.fetch = winAh.fakeFetch;
-            	resProto.clone = winAh.fakeFetchClone;
-            	winAh.hookInsts.add(hookInst);
-            	// 针对头条、抖音 secsdk.umd.js 的兼容性处理
-            	class AHFunction extends Function {
-            		call(thisArg, ...args) {
-            			if (thisArg && thisArg.__ajaxHooker && thisArg.__ajaxHooker.proxyXhr === thisArg) {
-            				thisArg = thisArg.__ajaxHooker.originalXhr;
-            			}
-            			return Reflect.apply(this, thisArg, args);
-            		}
-            		apply(thisArg, args) {
-            			if (thisArg && thisArg.__ajaxHooker && thisArg.__ajaxHooker.proxyXhr === thisArg) {
-            				thisArg = thisArg.__ajaxHooker.originalXhr;
-            			}
-            			return Reflect.apply(this, thisArg, args || []);
-            		}
-            	}
-            	function hookSecsdk(csrf) {
-            		Object.setPrototypeOf(csrf.nativeXMLHttpRequestSetRequestHeader, AHFunction.prototype);
-            		Object.setPrototypeOf(csrf.nativeXMLHttpRequestOpen, AHFunction.prototype);
-            		Object.setPrototypeOf(csrf.nativeXMLHttpRequestSend, AHFunction.prototype);
-            	}
-            	if (win.secsdk) {
-            		if (win.secsdk.csrf && win.secsdk.csrf.nativeXMLHttpRequestOpen) hookSecsdk(win.secsdk.csrf);
-            	} else {
-            		defineProp(win, "secsdk", emptyFn, (secsdk) => {
-            			delete win.secsdk;
-            			win.secsdk = secsdk;
-            			defineProp(secsdk, "csrf", emptyFn, (csrf) => {
-            				delete secsdk.csrf;
-            				secsdk.csrf = csrf;
-            				if (csrf.nativeXMLHttpRequestOpen) hookSecsdk(csrf);
-            			});
-            		});
-            	}
-            	return {
-            		hook: (fn) => hookInst.hookFns.push(fn),
-            		filter: (arr) => {
-            			if (Array.isArray(arr)) hookInst.filters = arr;
-            		},
-            		protect: () => {
-            			readonly(win, "XMLHttpRequest", winAh.fakeXHR);
-            			readonly(win, "fetch", winAh.fakeFetch);
-            			readonly(resProto, "clone", winAh.fakeFetchClone);
-            		},
-            		unhook: () => {
-            			winAh.hookInsts.delete(hookInst);
-            			if (!winAh.hookInsts.size) {
-            				writable(win, "XMLHttpRequest", winAh.realXHR);
-            				writable(win, "fetch", winAh.realFetch);
-            				writable(resProto, "clone", winAh.realFetchClone);
-            				delete win.__ajaxHooker;
-            			}
-            		},
-            	};
+            /* eslint-disable */
+            // ==UserScript==
+            // @name         ajaxHooker
+            // @author       cxxjackie
+            // @version      1.4.8
+            // @supportURL   https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
+            // @license      GNU LGPL-3.0
+            // ==/UserScript==
+            const ajaxHooker = function () {
+                const version = "1.4.8";
+                const hookInst = {
+                    hookFns: [],
+                    filters: [],
+                };
+                const win = window.unsafeWindow || document.defaultView || window;
+                let winAh = win.__ajaxHooker;
+                const resProto = win.Response.prototype;
+                const xhrResponses = ["response", "responseText", "responseXML"];
+                const fetchResponses = ["arrayBuffer", "blob", "formData", "json", "text"];
+                const xhrExtraProps = ["responseType", "timeout", "withCredentials"];
+                const fetchExtraProps = [
+                    "cache",
+                    "credentials",
+                    "integrity",
+                    "keepalive",
+                    "mode",
+                    "priority",
+                    "redirect",
+                    "referrer",
+                    "referrerPolicy",
+                    "signal",
+                ];
+                const xhrAsyncEvents = ["readystatechange", "load", "loadend"];
+                const getType = {}.toString.call.bind({}.toString);
+                const getDescriptor = Object.getOwnPropertyDescriptor.bind(Object);
+                const emptyFn = () => { };
+                const errorFn = (e) => console.error(e);
+                function isThenable(obj) {
+                    return obj && ["object", "function"].includes(typeof obj) && typeof obj.then === "function";
+                }
+                function catchError(fn, ...args) {
+                    try {
+                        const result = fn(...args);
+                        if (isThenable(result))
+                            return result.then(null, errorFn);
+                        return result;
+                    }
+                    catch (err) {
+                        console.error(err);
+                    }
+                }
+                function defineProp(obj, prop, getter, setter) {
+                    Object.defineProperty(obj, prop, {
+                        configurable: true,
+                        enumerable: true,
+                        get: getter,
+                        set: setter,
+                    });
+                }
+                function readonly(obj, prop, value = obj[prop]) {
+                    defineProp(obj, prop, () => value, emptyFn);
+                }
+                function writable(obj, prop, value = obj[prop]) {
+                    Object.defineProperty(obj, prop, {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: value,
+                    });
+                }
+                function parseHeaders(obj) {
+                    const headers = {};
+                    switch (getType(obj)) {
+                        case "[object String]":
+                            for (const line of obj.trim().split(/[\r\n]+/)) {
+                                const [header, value] = line.split(/(?<=^[^:]+)\s*:\s*/);
+                                if (!value)
+                                    continue;
+                                const lheader = header.toLowerCase();
+                                headers[lheader] = lheader in headers ? `${headers[lheader]}, ${value}` : value;
+                            }
+                            break;
+                        case "[object Headers]":
+                            for (const [key, val] of obj) {
+                                headers[key] = val;
+                            }
+                            break;
+                        case "[object Object]":
+                            return { ...obj };
+                    }
+                    return headers;
+                }
+                function stopImmediatePropagation() {
+                    this.ajaxHooker_isStopped = true;
+                }
+                class SyncThenable {
+                    then(fn) {
+                        fn && fn();
+                        return new SyncThenable();
+                    }
+                }
+                class AHRequest {
+                    constructor(request) {
+                        this.request = request;
+                        this.requestClone = { ...this.request };
+                    }
+                    _recoverRequestKey(key) {
+                        if (key in this.requestClone)
+                            this.request[key] = this.requestClone[key];
+                        else
+                            delete this.request[key];
+                    }
+                    shouldFilter(filters) {
+                        const { type, url, method, async } = this.request;
+                        return (filters.length &&
+                            !filters.find((obj) => {
+                                switch (true) {
+                                    case obj.type && obj.type !== type:
+                                    case getType(obj.url) === "[object String]" && !url.includes(obj.url):
+                                    case getType(obj.url) === "[object RegExp]" && !obj.url.test(url):
+                                    case obj.method && obj.method.toUpperCase() !== method.toUpperCase():
+                                    case "async" in obj && obj.async !== async:
+                                        return false;
+                                }
+                                return true;
+                            }));
+                    }
+                    waitForRequestKeys() {
+                        if (!this.request.async) {
+                            win.__ajaxHooker.hookInsts.forEach(({ hookFns, filters }) => {
+                                if (this.shouldFilter(filters))
+                                    return;
+                                hookFns.forEach((fn) => {
+                                    if (getType(fn) === "[object Function]")
+                                        catchError(fn, this.request);
+                                });
+                                for (const key in this.request) {
+                                    if (isThenable(this.request[key]))
+                                        this._recoverRequestKey(key);
+                                }
+                            });
+                            return new SyncThenable();
+                        }
+                        const promises = [];
+                        const ignoreKeys = new Set(["type", "async", "response"]);
+                        win.__ajaxHooker.hookInsts.forEach(({ hookFns, filters }) => {
+                            if (this.shouldFilter(filters))
+                                return;
+                            promises.push(Promise.all(hookFns.map((fn) => catchError(fn, this.request))).then(() => {
+                                const requestKeys = [];
+                                for (const key in this.request)
+                                    !ignoreKeys.has(key) && requestKeys.push(key);
+                                return Promise.all(requestKeys.map((key) => Promise.resolve(this.request[key]).then((val) => (this.request[key] = val), () => this._recoverRequestKey(key))));
+                            }));
+                        });
+                        return Promise.all(promises);
+                    }
+                    waitForResponseKeys(response) {
+                        const responseKeys = this.request.type === "xhr" ? xhrResponses : fetchResponses;
+                        if (!this.request.async) {
+                            if (getType(this.request.response) === "[object Function]") {
+                                catchError(this.request.response, response);
+                                responseKeys.forEach((key) => {
+                                    if ("get" in getDescriptor(response, key) || isThenable(response[key])) {
+                                        delete response[key];
+                                    }
+                                });
+                            }
+                            return new SyncThenable();
+                        }
+                        return Promise.resolve(catchError(this.request.response, response)).then(() => Promise.all(responseKeys.map((key) => {
+                            const descriptor = getDescriptor(response, key);
+                            if (descriptor && "value" in descriptor) {
+                                return Promise.resolve(descriptor.value).then((val) => (response[key] = val), () => delete response[key]);
+                            }
+                            else {
+                                delete response[key];
+                            }
+                        })));
+                    }
+                }
+                const proxyHandler = {
+                    get(target, prop) {
+                        const descriptor = getDescriptor(target, prop);
+                        if (descriptor && !descriptor.configurable && !descriptor.writable && !descriptor.get)
+                            return target[prop];
+                        const ah = target.__ajaxHooker;
+                        if (ah && ah.proxyProps) {
+                            if (prop in ah.proxyProps) {
+                                const pDescriptor = ah.proxyProps[prop];
+                                if ("get" in pDescriptor)
+                                    return pDescriptor.get();
+                                if (typeof pDescriptor.value === "function")
+                                    return pDescriptor.value.bind(ah);
+                                return pDescriptor.value;
+                            }
+                            if (typeof target[prop] === "function")
+                                return target[prop].bind(target);
+                        }
+                        return target[prop];
+                    },
+                    set(target, prop, value) {
+                        const descriptor = getDescriptor(target, prop);
+                        if (descriptor && !descriptor.configurable && !descriptor.writable && !descriptor.set)
+                            return true;
+                        const ah = target.__ajaxHooker;
+                        if (ah && ah.proxyProps && prop in ah.proxyProps) {
+                            const pDescriptor = ah.proxyProps[prop];
+                            pDescriptor.set ? pDescriptor.set(value) : (pDescriptor.value = value);
+                        }
+                        else {
+                            target[prop] = value;
+                        }
+                        return true;
+                    },
+                };
+                class XhrHooker {
+                    constructor(xhr) {
+                        const ah = this;
+                        Object.assign(ah, {
+                            originalXhr: xhr,
+                            proxyXhr: new Proxy(xhr, proxyHandler),
+                            resThenable: new SyncThenable(),
+                            proxyProps: {},
+                            proxyEvents: {},
+                        });
+                        xhr.addEventListener("readystatechange", (e) => {
+                            if (ah.proxyXhr.readyState === 4 && ah.request && typeof ah.request.response === "function") {
+                                const response = {
+                                    finalUrl: ah.proxyXhr.responseURL,
+                                    status: ah.proxyXhr.status,
+                                    responseHeaders: parseHeaders(ah.proxyXhr.getAllResponseHeaders()),
+                                };
+                                const tempValues = {};
+                                for (const key of xhrResponses) {
+                                    try {
+                                        tempValues[key] = ah.originalXhr[key];
+                                    }
+                                    catch (err) { }
+                                    defineProp(response, key, () => {
+                                        return (response[key] = tempValues[key]);
+                                    }, (val) => {
+                                        delete response[key];
+                                        response[key] = val;
+                                    });
+                                }
+                                ah.resThenable = new AHRequest(ah.request).waitForResponseKeys(response).then(() => {
+                                    for (const key of xhrResponses) {
+                                        ah.proxyProps[key] = {
+                                            get: () => {
+                                                if (!(key in response))
+                                                    response[key] = tempValues[key];
+                                                return response[key];
+                                            },
+                                        };
+                                    }
+                                });
+                            }
+                            ah.dispatchEvent(e);
+                        });
+                        xhr.addEventListener("load", (e) => ah.dispatchEvent(e));
+                        xhr.addEventListener("loadend", (e) => ah.dispatchEvent(e));
+                        for (const evt of xhrAsyncEvents) {
+                            const onEvt = "on" + evt;
+                            ah.proxyProps[onEvt] = {
+                                get: () => ah.proxyEvents[onEvt] || null,
+                                set: (val) => ah.addEvent(onEvt, val),
+                            };
+                        }
+                        for (const method of ["setRequestHeader", "addEventListener", "removeEventListener", "open", "send"]) {
+                            ah.proxyProps[method] = { value: ah[method] };
+                        }
+                    }
+                    toJSON() { } // Converting circular structure to JSON
+                    addEvent(type, event) {
+                        if (type.startsWith("on")) {
+                            this.proxyEvents[type] = typeof event === "function" ? event : null;
+                        }
+                        else {
+                            if (typeof event === "object" && event !== null)
+                                event = event.handleEvent;
+                            if (typeof event !== "function")
+                                return;
+                            this.proxyEvents[type] = this.proxyEvents[type] || new Set();
+                            this.proxyEvents[type].add(event);
+                        }
+                    }
+                    removeEvent(type, event) {
+                        if (type.startsWith("on")) {
+                            this.proxyEvents[type] = null;
+                        }
+                        else {
+                            if (typeof event === "object" && event !== null)
+                                event = event.handleEvent;
+                            this.proxyEvents[type] && this.proxyEvents[type].delete(event);
+                        }
+                    }
+                    dispatchEvent(e) {
+                        e.stopImmediatePropagation = stopImmediatePropagation;
+                        defineProp(e, "target", () => this.proxyXhr);
+                        defineProp(e, "currentTarget", () => this.proxyXhr);
+                        defineProp(e, "srcElement", () => this.proxyXhr);
+                        this.proxyEvents[e.type] &&
+                            this.proxyEvents[e.type].forEach((fn) => {
+                                this.resThenable.then(() => !e.ajaxHooker_isStopped && fn.call(this.proxyXhr, e));
+                            });
+                        if (e.ajaxHooker_isStopped)
+                            return;
+                        const onEvent = this.proxyEvents["on" + e.type];
+                        onEvent && this.resThenable.then(onEvent.bind(this.proxyXhr, e));
+                    }
+                    setRequestHeader(header, value) {
+                        this.originalXhr.setRequestHeader(header, value);
+                        if (!this.request)
+                            return;
+                        const headers = this.request.headers;
+                        headers[header] = header in headers ? `${headers[header]}, ${value}` : value;
+                    }
+                    addEventListener(...args) {
+                        if (xhrAsyncEvents.includes(args[0])) {
+                            this.addEvent(args[0], args[1]);
+                        }
+                        else {
+                            this.originalXhr.addEventListener(...args);
+                        }
+                    }
+                    removeEventListener(...args) {
+                        if (xhrAsyncEvents.includes(args[0])) {
+                            this.removeEvent(args[0], args[1]);
+                        }
+                        else {
+                            this.originalXhr.removeEventListener(...args);
+                        }
+                    }
+                    open(method, url, async = true, ...args) {
+                        this.request = {
+                            type: "xhr",
+                            url: url.toString(),
+                            method: method.toUpperCase(),
+                            abort: false,
+                            headers: {},
+                            data: null,
+                            response: null,
+                            async: !!async,
+                        };
+                        this.openArgs = args;
+                        this.resThenable = new SyncThenable();
+                        ["responseURL", "readyState", "status", "statusText", ...xhrResponses].forEach((key) => {
+                            delete this.proxyProps[key];
+                        });
+                        return this.originalXhr.open(method, url, async, ...args);
+                    }
+                    send(data) {
+                        const ah = this;
+                        const xhr = ah.originalXhr;
+                        const request = ah.request;
+                        if (!request)
+                            return xhr.send(data);
+                        request.data = data;
+                        new AHRequest(request).waitForRequestKeys().then(() => {
+                            if (request.abort) {
+                                if (typeof request.response === "function") {
+                                    Object.assign(ah.proxyProps, {
+                                        responseURL: { value: request.url },
+                                        readyState: { value: 4 },
+                                        status: { value: 200 },
+                                        statusText: { value: "OK" },
+                                    });
+                                    xhrAsyncEvents.forEach((evt) => xhr.dispatchEvent(new Event(evt)));
+                                }
+                            }
+                            else {
+                                xhr.open(request.method, request.url, request.async, ...ah.openArgs);
+                                for (const header in request.headers) {
+                                    xhr.setRequestHeader(header, request.headers[header]);
+                                }
+                                for (const prop of xhrExtraProps) {
+                                    if (prop in request)
+                                        xhr[prop] = request[prop];
+                                }
+                                xhr.send(request.data);
+                            }
+                        });
+                    }
+                }
+                function fakeXHR() {
+                    const xhr = new winAh.realXHR();
+                    if ("__ajaxHooker" in xhr)
+                        console.warn("检测到不同版本的ajaxHooker，可能发生冲突！");
+                    xhr.__ajaxHooker = new XhrHooker(xhr);
+                    return xhr.__ajaxHooker.proxyXhr;
+                }
+                fakeXHR.prototype = win.XMLHttpRequest.prototype;
+                Object.keys(win.XMLHttpRequest).forEach((key) => (fakeXHR[key] = win.XMLHttpRequest[key]));
+                function fakeFetch(url, options = {}) {
+                    if (!url)
+                        return winAh.realFetch.call(win, url, options);
+                    return new Promise(async (resolve, reject) => {
+                        const init = {};
+                        if (getType(url) === "[object Request]") {
+                            init.method = url.method;
+                            init.headers = url.headers;
+                            if (url.body)
+                                init.body = await url.arrayBuffer();
+                            for (const prop of fetchExtraProps)
+                                init[prop] = url[prop];
+                            url = url.url;
+                        }
+                        url = url.toString();
+                        Object.assign(init, options);
+                        init.method = init.method || "GET";
+                        init.headers = init.headers || {};
+                        const request = {
+                            type: "fetch",
+                            url: url,
+                            method: init.method.toUpperCase(),
+                            abort: false,
+                            headers: parseHeaders(init.headers),
+                            data: init.body,
+                            response: null,
+                            async: true,
+                        };
+                        const req = new AHRequest(request);
+                        await req.waitForRequestKeys();
+                        if (request.abort) {
+                            if (typeof request.response === "function") {
+                                const response = {
+                                    finalUrl: request.url,
+                                    status: 200,
+                                    responseHeaders: {},
+                                };
+                                await req.waitForResponseKeys(response);
+                                const key = fetchResponses.find((k) => k in response);
+                                let val = response[key];
+                                if (key === "json" && typeof val === "object") {
+                                    val = catchError(JSON.stringify.bind(JSON), val);
+                                }
+                                const res = new Response(val, {
+                                    status: 200,
+                                    statusText: "OK",
+                                });
+                                defineProp(res, "type", () => "basic");
+                                defineProp(res, "url", () => request.url);
+                                resolve(res);
+                            }
+                            else {
+                                reject(new DOMException("aborted", "AbortError"));
+                            }
+                            return;
+                        }
+                        init.method = request.method;
+                        init.headers = request.headers;
+                        init.body = request.data;
+                        for (const prop of fetchExtraProps) {
+                            if (prop in request)
+                                init[prop] = request[prop];
+                        }
+                        winAh.realFetch.call(win, request.url, init).then((res) => {
+                            if (typeof request.response === "function") {
+                                const response = {
+                                    finalUrl: res.url,
+                                    status: res.status,
+                                    responseHeaders: parseHeaders(res.headers),
+                                };
+                                if (res.ok) {
+                                    fetchResponses.forEach((key) => (res[key] = function () {
+                                        if (key in response)
+                                            return Promise.resolve(response[key]);
+                                        return resProto[key].call(this).then((val) => {
+                                            response[key] = val;
+                                            return req
+                                                .waitForResponseKeys(response)
+                                                .then(() => (key in response ? response[key] : val));
+                                        });
+                                    }));
+                                }
+                                else {
+                                    catchError(request.response, response);
+                                }
+                            }
+                            resolve(res);
+                        }, reject);
+                    });
+                }
+                function fakeFetchClone() {
+                    const descriptors = Object.getOwnPropertyDescriptors(this);
+                    const res = winAh.realFetchClone.call(this);
+                    Object.defineProperties(res, descriptors);
+                    return res;
+                }
+                winAh = win.__ajaxHooker = winAh || {
+                    version,
+                    fakeXHR,
+                    fakeFetch,
+                    fakeFetchClone,
+                    realXHR: win.XMLHttpRequest,
+                    realFetch: win.fetch,
+                    realFetchClone: resProto.clone,
+                    hookInsts: new Set(),
+                };
+                if (winAh.version !== version)
+                    console.warn("检测到不同版本的ajaxHooker，可能发生冲突！");
+                win.XMLHttpRequest = winAh.fakeXHR;
+                win.fetch = winAh.fakeFetch;
+                resProto.clone = winAh.fakeFetchClone;
+                winAh.hookInsts.add(hookInst);
+                // 针对头条、抖音 secsdk.umd.js 的兼容性处理
+                class AHFunction extends Function {
+                    call(thisArg, ...args) {
+                        if (thisArg && thisArg.__ajaxHooker && thisArg.__ajaxHooker.proxyXhr === thisArg) {
+                            thisArg = thisArg.__ajaxHooker.originalXhr;
+                        }
+                        return Reflect.apply(this, thisArg, args);
+                    }
+                    apply(thisArg, args) {
+                        if (thisArg && thisArg.__ajaxHooker && thisArg.__ajaxHooker.proxyXhr === thisArg) {
+                            thisArg = thisArg.__ajaxHooker.originalXhr;
+                        }
+                        return Reflect.apply(this, thisArg, args || []);
+                    }
+                }
+                function hookSecsdk(csrf) {
+                    Object.setPrototypeOf(csrf.nativeXMLHttpRequestSetRequestHeader, AHFunction.prototype);
+                    Object.setPrototypeOf(csrf.nativeXMLHttpRequestOpen, AHFunction.prototype);
+                    Object.setPrototypeOf(csrf.nativeXMLHttpRequestSend, AHFunction.prototype);
+                }
+                if (win.secsdk) {
+                    if (win.secsdk.csrf && win.secsdk.csrf.nativeXMLHttpRequestOpen)
+                        hookSecsdk(win.secsdk.csrf);
+                }
+                else {
+                    defineProp(win, "secsdk", emptyFn, (secsdk) => {
+                        delete win.secsdk;
+                        win.secsdk = secsdk;
+                        defineProp(secsdk, "csrf", emptyFn, (csrf) => {
+                            delete secsdk.csrf;
+                            secsdk.csrf = csrf;
+                            if (csrf.nativeXMLHttpRequestOpen)
+                                hookSecsdk(csrf);
+                        });
+                    });
+                }
+                return {
+                    hook: (fn) => hookInst.hookFns.push(fn),
+                    filter: (arr) => {
+                        if (Array.isArray(arr))
+                            hookInst.filters = arr;
+                    },
+                    protect: () => {
+                        readonly(win, "XMLHttpRequest", winAh.fakeXHR);
+                        readonly(win, "fetch", winAh.fakeFetch);
+                        readonly(resProto, "clone", winAh.fakeFetchClone);
+                    },
+                    unhook: () => {
+                        winAh.hookInsts.delete(hookInst);
+                        if (!winAh.hookInsts.size) {
+                            writable(win, "XMLHttpRequest", winAh.realXHR);
+                            writable(win, "fetch", winAh.realFetch);
+                            writable(resProto, "clone", winAh.realFetchClone);
+                            delete win.__ajaxHooker;
+                        }
+                    },
+                };
             };
 
-            // ==UserScript==
-            // @name         ajaxHooker
-            // @author       cxxjackie
-            // @version      1.2.4
-            // @supportURL   https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
-            // ==/UserScript==
-
-            const AjaxHooker1_2_4 = function () {
-            	return (function () {
-            		const win = window.unsafeWindow || document.defaultView || window;
-            		const hookFns = [];
-            		const realXhr = win.XMLHttpRequest;
-            		const resProto = win.Response.prototype;
-            		const toString = Object.prototype.toString;
-            		const realFetch = win.fetch;
-            		const xhrResponses = ["response", "responseText", "responseXML"];
-            		const fetchResponses = ["arrayBuffer", "blob", "formData", "json", "text"];
-            		const xhrAsyncEvents = ["readystatechange", "load", "loadend"];
-            		let filter;
-            		function emptyFn() {}
-            		function errorFn(err) {
-            			console.error(err);
-            		}
-            		function defineProp(obj, prop, getter, setter) {
-            			Object.defineProperty(obj, prop, {
-            				configurable: true,
-            				enumerable: true,
-            				get: getter,
-            				set: setter,
-            			});
-            		}
-            		function readonly(obj, prop, value = obj[prop]) {
-            			defineProp(obj, prop, () => value, emptyFn);
-            		}
-            		function writable(obj, prop, value = obj[prop]) {
-            			Object.defineProperty(obj, prop, {
-            				configurable: true,
-            				enumerable: true,
-            				writable: true,
-            				value: value,
-            			});
-            		}
-            		function toFilterObj(obj) {
-            			return {
-            				type: obj.type,
-            				url: obj.url,
-            				method: obj.method && obj.method.toUpperCase(),
-            			};
-            		}
-            		function shouldFilter(type, url, method) {
-            			return (
-            				filter &&
-            				!filter.find(
-            					(obj) =>
-            						(!obj.type || obj.type === type) &&
-            						(!obj.url ||
-            							(toString.call(obj.url) === "[object String]"
-            								? url.includes(obj.url)
-            								: obj.url.test(url))) &&
-            						(!obj.method || obj.method === method.toUpperCase())
-            				)
-            			);
-            		}
-            		function lookupGetter(obj, prop) {
-            			let getter;
-            			let proto = obj;
-            			while (proto) {
-            				const descriptor = Object.getOwnPropertyDescriptor(proto, prop);
-            				getter = descriptor && descriptor.get;
-            				if (getter) break;
-            				proto = Object.getPrototypeOf(proto);
-            			}
-            			return getter ? getter.bind(obj) : emptyFn;
-            		}
-            		function waitForHookFns(request) {
-            			return Promise.all(
-            				hookFns.map((fn) => Promise.resolve(fn(request)).then(emptyFn, errorFn))
-            			);
-            		}
-            		function waitForRequestKeys(request, requestClone) {
-            			return Promise.all(
-            				["url", "method", "abort", "headers", "data"].map((key) => {
-            					return Promise.resolve(request[key]).then(
-            						(val) => (request[key] = val),
-            						() => (request[key] = requestClone[key])
-            					);
-            				})
-            			);
-            		}
-            		function fakeEventSIP() {
-            			this.ajaxHooker_stopped = true;
-            		}
-            		function xhrDelegateEvent(e) {
-            			const xhr = e.target;
-            			e.stopImmediatePropagation = fakeEventSIP;
-            			xhr.__ajaxHooker.hookedEvents[e.type].forEach(
-            				(fn) => !e.ajaxHooker_stopped && fn.call(xhr, e)
-            			);
-            			const onEvent = xhr.__ajaxHooker.hookedEvents["on" + e.type];
-            			typeof onEvent === "function" && onEvent.call(xhr, e);
-            		}
-            		function xhrReadyStateChange(e) {
-            			if (e.target.readyState === 4) {
-            				e.target.dispatchEvent(
-            					new CustomEvent("ajaxHooker_responseReady", { detail: e })
-            				);
-            			} else {
-            				e.target.__ajaxHooker.delegateEvent(e);
-            			}
-            		}
-            		function xhrLoadAndLoadend(e) {
-            			e.target.__ajaxHooker.delegateEvent(e);
-            		}
-            		function fakeXhrOpen(method, url, ...args) {
-            			const ah = this.__ajaxHooker;
-            			ah.url = url.toString();
-            			ah.method = method.toUpperCase();
-            			ah.openArgs = args;
-            			ah.headers = {};
-            			return ah.originalMethods.open(method, url, ...args);
-            		}
-            		function fakeXhr() {
-            			const xhr = new realXhr();
-            			let ah = xhr.__ajaxHooker;
-            			if (!ah) {
-            				ah = xhr.__ajaxHooker = {
-            					headers: {},
-            					hookedEvents: {
-            						readystatechange: new Set(),
-            						load: new Set(),
-            						loadend: new Set(),
-            					},
-            					delegateEvent: xhrDelegateEvent,
-            					originalGetters: {},
-            					originalMethods: {},
-            				};
-            				xhr.addEventListener("readystatechange", xhrReadyStateChange);
-            				xhr.addEventListener("load", xhrLoadAndLoadend);
-            				xhr.addEventListener("loadend", xhrLoadAndLoadend);
-            				for (const key of xhrResponses) {
-            					ah.originalGetters[key] = lookupGetter(xhr, key);
-            				}
-            				for (const method of [
-            					"open",
-            					"setRequestHeader",
-            					"addEventListener",
-            					"removeEventListener",
-            				]) {
-            					ah.originalMethods[method] = xhr[method].bind(xhr);
-            				}
-            				xhr.open = fakeXhrOpen;
-            				xhr.setRequestHeader = (header, value) => {
-            					ah.originalMethods.setRequestHeader(header, value);
-            					if (xhr.readyState === 1) {
-            						if (ah.headers[header]) {
-            							ah.headers[header] += ", " + value;
-            						} else {
-            							ah.headers[header] = value;
-            						}
-            					}
-            				};
-            				xhr.addEventListener = function (...args) {
-            					if (xhrAsyncEvents.includes(args[0])) {
-            						ah.hookedEvents[args[0]].add(args[1]);
-            					} else {
-            						ah.originalMethods.addEventListener(...args);
-            					}
-            				};
-            				xhr.removeEventListener = function (...args) {
-            					if (xhrAsyncEvents.includes(args[0])) {
-            						ah.hookedEvents[args[0]].delete(args[1]);
-            					} else {
-            						ah.originalMethods.removeEventListener(...args);
-            					}
-            				};
-            				xhrAsyncEvents.forEach((evt) => {
-            					const onEvt = "on" + evt;
-            					defineProp(
-            						xhr,
-            						onEvt,
-            						() => {
-            							return ah.hookedEvents[onEvt] || null;
-            						},
-            						(val) => {
-            							ah.hookedEvents[onEvt] = typeof val === "function" ? val : null;
-            						}
-            					);
-            				});
-            			}
-            			const realSend = xhr.send.bind(xhr);
-            			xhr.send = function (data) {
-            				if (xhr.readyState !== 1) return realSend(data);
-            				ah.delegateEvent = xhrDelegateEvent;
-            				xhrResponses.forEach((prop) => {
-            					delete xhr[prop]; // delete descriptor
-            				});
-            				if (shouldFilter("xhr", ah.url, ah.method)) {
-            					xhr.addEventListener("ajaxHooker_responseReady", (e) => {
-            						ah.delegateEvent(e.detail);
-            					});
-            					return realSend(data);
-            				}
-            				try {
-            					const request = {
-            						type: "xhr",
-            						url: ah.url,
-            						method: ah.method,
-            						abort: false,
-            						headers: ah.headers,
-            						data: data,
-            						response: null,
-            					};
-            					const requestClone = { ...request };
-            					waitForHookFns(request).then(() => {
-            						waitForRequestKeys(request, requestClone).then(() => {
-            							if (request.abort) return;
-            							ah.originalMethods.open(
-            								request.method,
-            								request.url,
-            								...ah.openArgs
-            							);
-            							for (const header in request.headers) {
-            								ah.originalMethods.setRequestHeader(
-            									header,
-            									request.headers[header]
-            								);
-            							}
-            							data = request.data;
-            							xhr.addEventListener("ajaxHooker_responseReady", (e) => {
-            								try {
-            									if (typeof request.response === "function") {
-            										const arg = {
-            											finalUrl: xhr.responseURL,
-            											status: xhr.status,
-            											responseHeaders: {},
-            										};
-            										for (const line of xhr
-            											.getAllResponseHeaders()
-            											.trim()
-            											.split(/[\r\n]+/)) {
-            											const parts = line.split(/:\s*/);
-            											if (parts.length === 2) {
-            												const lheader = parts[0].toLowerCase();
-            												if (arg.responseHeaders[lheader]) {
-            													arg.responseHeaders[lheader] += ", " + parts[1];
-            												} else {
-            													arg.responseHeaders[lheader] = parts[1];
-            												}
-            											}
-            										}
-            										xhrResponses.forEach((prop) => {
-            											defineProp(
-            												arg,
-            												prop,
-            												() => {
-            													return (arg[prop] = ah.originalGetters[prop]());
-            												},
-            												(val) => {
-            													delete arg[prop];
-            													arg[prop] = val;
-            												}
-            											);
-            											defineProp(xhr, prop, () => {
-            												const val = ah.originalGetters[prop]();
-            												xhr.dispatchEvent(
-            													new CustomEvent("ajaxHooker_readResponse", {
-            														detail: { prop, val },
-            													})
-            												);
-            												return val;
-            											});
-            										});
-            										xhr.addEventListener("ajaxHooker_readResponse", (e) => {
-            											arg[e.detail.prop] = e.detail.val;
-            										});
-            										const resPromise = Promise.resolve(
-            											request.response(arg)
-            										).then(() => {
-            											const task = [];
-            											xhrResponses.forEach((prop) => {
-            												const descriptor = Object.getOwnPropertyDescriptor(
-            													arg,
-            													prop
-            												);
-            												if (descriptor && "value" in descriptor) {
-            													task.push(
-            														Promise.resolve(descriptor.value).then((val) => {
-            															arg[prop] = val;
-            															defineProp(xhr, prop, () => {
-            																xhr.dispatchEvent(
-            																	new CustomEvent("ajaxHooker_readResponse", {
-            																		detail: { prop, val },
-            																	})
-            																);
-            																return val;
-            															});
-            														}, emptyFn)
-            													);
-            												}
-            											});
-            											return Promise.all(task);
-            										}, errorFn);
-            										const eventsClone = {};
-            										xhrAsyncEvents.forEach((type) => {
-            											eventsClone[type] = new Set([...ah.hookedEvents[type]]);
-            											eventsClone["on" + type] = ah.hookedEvents["on" + type];
-            										});
-            										ah.delegateEvent = (event) =>
-            											resPromise.then(() => {
-            												event.stopImmediatePropagation = fakeEventSIP;
-            												eventsClone[event.type].forEach(
-            													(fn) =>
-            														!event.ajaxHooker_stopped && fn.call(xhr, event)
-            												);
-            												const onEvent = eventsClone["on" + event.type];
-            												typeof onEvent === "function" &&
-            													onEvent.call(xhr, event);
-            											});
-            									}
-            								} catch (err) {
-            									console.error(err);
-            								}
-            								ah.delegateEvent(e.detail);
-            							});
-            							realSend(data);
-            						});
-            					});
-            				} catch (err) {
-            					console.error(err);
-            					realSend(data);
-            				}
-            			};
-            			return xhr;
-            		}
-            		function hookFetchResponse(response, arg, callback) {
-            			fetchResponses.forEach((prop) => {
-            				response[prop] = () =>
-            					new Promise((resolve, reject) => {
-            						resProto[prop].call(response).then((res) => {
-            							if (prop in arg) {
-            								resolve(arg[prop]);
-            							} else {
-            								try {
-            									arg[prop] = res;
-            									Promise.resolve(callback(arg)).then(() => {
-            										if (prop in arg) {
-            											Promise.resolve(arg[prop]).then(
-            												(val) => resolve((arg[prop] = val)),
-            												() => resolve(res)
-            											);
-            										} else {
-            											resolve(res);
-            										}
-            									}, errorFn);
-            								} catch (err) {
-            									console.error(err);
-            									resolve(res);
-            								}
-            							}
-            						}, reject);
-            					});
-            			});
-            		}
-            		function fakeFetch(url, init) {
-            			if (url && typeof url.toString === "function") {
-            				url = url.toString();
-            				init = init || {};
-            				init.method = init.method || "GET";
-            				init.headers = init.headers || {};
-            				if (shouldFilter("fetch", url, init.method))
-            					return realFetch.call(win, url, init);
-            				const request = {
-            					type: "fetch",
-            					url: url,
-            					method: init.method.toUpperCase(),
-            					abort: false,
-            					headers: {},
-            					data: init.body,
-            					response: null,
-            				};
-            				if (toString.call(init.headers) === "[object Headers]") {
-            					for (const [key, val] of init.headers) {
-            						request.headers[key] = val;
-            					}
-            				} else {
-            					request.headers = { ...init.headers };
-            				}
-            				const requestClone = { ...request };
-            				return new Promise((resolve, reject) => {
-            					try {
-            						waitForHookFns(request).then(() => {
-            							waitForRequestKeys(request, requestClone).then(() => {
-            								if (request.abort) return reject("aborted");
-            								url = request.url;
-            								init.method = request.method;
-            								init.headers = request.headers;
-            								init.body = request.data;
-            								realFetch.call(win, url, init).then((response) => {
-            									if (typeof request.response === "function") {
-            										const arg = {
-            											finalUrl: response.url,
-            											status: response.status,
-            											responseHeaders: {},
-            										};
-            										for (const [key, val] of response.headers) {
-            											arg.responseHeaders[key] = val;
-            										}
-            										hookFetchResponse(response, arg, request.response);
-            										response.clone = () => {
-            											const resClone = resProto.clone.call(response);
-            											hookFetchResponse(resClone, arg, request.response);
-            											return resClone;
-            										};
-            									}
-            									resolve(response);
-            								}, reject);
-            							});
-            						});
-            					} catch (err) {
-            						console.error(err);
-            						return realFetch.call(win, url, init);
-            					}
-            				});
-            			} else {
-            				return realFetch.call(win, url, init);
-            			}
-            		}
-            		win.XMLHttpRequest = fakeXhr;
-            		Object.keys(realXhr).forEach((key) => (fakeXhr[key] = realXhr[key]));
-            		fakeXhr.prototype = realXhr.prototype;
-            		win.fetch = fakeFetch;
-            		return {
-            			hook: (fn) => hookFns.push(fn),
-            			filter: (arr) => {
-            				filter = Array.isArray(arr) && arr.map(toFilterObj);
-            			},
-            			protect: () => {
-            				readonly(win, "XMLHttpRequest", fakeXhr);
-            				readonly(win, "fetch", fakeFetch);
-            			},
-            			unhook: () => {
-            				writable(win, "XMLHttpRequest", realXhr);
-            				writable(win, "fetch", realFetch);
-            			},
-            		};
-            	})();
+            // ==UserScript==
+            // @name         ajaxHooker
+            // @author       cxxjackie
+            // @version      1.2.4
+            // @supportURL   https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
+            // ==/UserScript==
+            const AjaxHooker1_2_4 = function () {
+                return (function () {
+                    const win = window.unsafeWindow || document.defaultView || window;
+                    const hookFns = [];
+                    const realXhr = win.XMLHttpRequest;
+                    const resProto = win.Response.prototype;
+                    const toString = Object.prototype.toString;
+                    const realFetch = win.fetch;
+                    const xhrResponses = ["response", "responseText", "responseXML"];
+                    const fetchResponses = ["arrayBuffer", "blob", "formData", "json", "text"];
+                    const xhrAsyncEvents = ["readystatechange", "load", "loadend"];
+                    let filter;
+                    function emptyFn() { }
+                    function errorFn(err) {
+                        console.error(err);
+                    }
+                    function defineProp(obj, prop, getter, setter) {
+                        Object.defineProperty(obj, prop, {
+                            configurable: true,
+                            enumerable: true,
+                            get: getter,
+                            set: setter,
+                        });
+                    }
+                    function readonly(obj, prop, value = obj[prop]) {
+                        defineProp(obj, prop, () => value, emptyFn);
+                    }
+                    function writable(obj, prop, value = obj[prop]) {
+                        Object.defineProperty(obj, prop, {
+                            configurable: true,
+                            enumerable: true,
+                            writable: true,
+                            value: value,
+                        });
+                    }
+                    function toFilterObj(obj) {
+                        return {
+                            type: obj.type,
+                            url: obj.url,
+                            method: obj.method && obj.method.toUpperCase(),
+                        };
+                    }
+                    function shouldFilter(type, url, method) {
+                        return (filter &&
+                            !filter.find((obj) => (!obj.type || obj.type === type) &&
+                                (!obj.url ||
+                                    (toString.call(obj.url) === "[object String]"
+                                        ? url.includes(obj.url)
+                                        : obj.url.test(url))) &&
+                                (!obj.method || obj.method === method.toUpperCase())));
+                    }
+                    function lookupGetter(obj, prop) {
+                        let getter;
+                        let proto = obj;
+                        while (proto) {
+                            const descriptor = Object.getOwnPropertyDescriptor(proto, prop);
+                            getter = descriptor && descriptor.get;
+                            if (getter)
+                                break;
+                            proto = Object.getPrototypeOf(proto);
+                        }
+                        return getter ? getter.bind(obj) : emptyFn;
+                    }
+                    function waitForHookFns(request) {
+                        return Promise.all(hookFns.map((fn) => Promise.resolve(fn(request)).then(emptyFn, errorFn)));
+                    }
+                    function waitForRequestKeys(request, requestClone) {
+                        return Promise.all(["url", "method", "abort", "headers", "data"].map((key) => {
+                            return Promise.resolve(request[key]).then((val) => (request[key] = val), () => (request[key] = requestClone[key]));
+                        }));
+                    }
+                    function fakeEventSIP() {
+                        this.ajaxHooker_stopped = true;
+                    }
+                    function xhrDelegateEvent(e) {
+                        const xhr = e.target;
+                        e.stopImmediatePropagation = fakeEventSIP;
+                        xhr.__ajaxHooker.hookedEvents[e.type].forEach((fn) => !e.ajaxHooker_stopped && fn.call(xhr, e));
+                        const onEvent = xhr.__ajaxHooker.hookedEvents["on" + e.type];
+                        typeof onEvent === "function" && onEvent.call(xhr, e);
+                    }
+                    function xhrReadyStateChange(e) {
+                        if (e.target.readyState === 4) {
+                            e.target.dispatchEvent(new CustomEvent("ajaxHooker_responseReady", { detail: e }));
+                        }
+                        else {
+                            e.target.__ajaxHooker.delegateEvent(e);
+                        }
+                    }
+                    function xhrLoadAndLoadend(e) {
+                        e.target.__ajaxHooker.delegateEvent(e);
+                    }
+                    function fakeXhrOpen(method, url, ...args) {
+                        const ah = this.__ajaxHooker;
+                        ah.url = url.toString();
+                        ah.method = method.toUpperCase();
+                        ah.openArgs = args;
+                        ah.headers = {};
+                        return ah.originalMethods.open(method, url, ...args);
+                    }
+                    function fakeXhr() {
+                        const xhr = new realXhr();
+                        let ah = xhr.__ajaxHooker;
+                        if (!ah) {
+                            ah = xhr.__ajaxHooker = {
+                                headers: {},
+                                hookedEvents: {
+                                    readystatechange: new Set(),
+                                    load: new Set(),
+                                    loadend: new Set(),
+                                },
+                                delegateEvent: xhrDelegateEvent,
+                                originalGetters: {},
+                                originalMethods: {},
+                            };
+                            xhr.addEventListener("readystatechange", xhrReadyStateChange);
+                            xhr.addEventListener("load", xhrLoadAndLoadend);
+                            xhr.addEventListener("loadend", xhrLoadAndLoadend);
+                            for (const key of xhrResponses) {
+                                ah.originalGetters[key] = lookupGetter(xhr, key);
+                            }
+                            for (const method of [
+                                "open",
+                                "setRequestHeader",
+                                "addEventListener",
+                                "removeEventListener",
+                            ]) {
+                                ah.originalMethods[method] = xhr[method].bind(xhr);
+                            }
+                            xhr.open = fakeXhrOpen;
+                            xhr.setRequestHeader = (header, value) => {
+                                ah.originalMethods.setRequestHeader(header, value);
+                                if (xhr.readyState === 1) {
+                                    if (ah.headers[header]) {
+                                        ah.headers[header] += ", " + value;
+                                    }
+                                    else {
+                                        ah.headers[header] = value;
+                                    }
+                                }
+                            };
+                            xhr.addEventListener = function (...args) {
+                                if (xhrAsyncEvents.includes(args[0])) {
+                                    ah.hookedEvents[args[0]].add(args[1]);
+                                }
+                                else {
+                                    ah.originalMethods.addEventListener(...args);
+                                }
+                            };
+                            xhr.removeEventListener = function (...args) {
+                                if (xhrAsyncEvents.includes(args[0])) {
+                                    ah.hookedEvents[args[0]].delete(args[1]);
+                                }
+                                else {
+                                    ah.originalMethods.removeEventListener(...args);
+                                }
+                            };
+                            xhrAsyncEvents.forEach((evt) => {
+                                const onEvt = "on" + evt;
+                                defineProp(xhr, onEvt, () => {
+                                    return ah.hookedEvents[onEvt] || null;
+                                }, (val) => {
+                                    ah.hookedEvents[onEvt] = typeof val === "function" ? val : null;
+                                });
+                            });
+                        }
+                        const realSend = xhr.send.bind(xhr);
+                        xhr.send = function (data) {
+                            if (xhr.readyState !== 1)
+                                return realSend(data);
+                            ah.delegateEvent = xhrDelegateEvent;
+                            xhrResponses.forEach((prop) => {
+                                delete xhr[prop]; // delete descriptor
+                            });
+                            if (shouldFilter("xhr", ah.url, ah.method)) {
+                                xhr.addEventListener("ajaxHooker_responseReady", (e) => {
+                                    ah.delegateEvent(e.detail);
+                                });
+                                return realSend(data);
+                            }
+                            try {
+                                const request = {
+                                    type: "xhr",
+                                    url: ah.url,
+                                    method: ah.method,
+                                    abort: false,
+                                    headers: ah.headers,
+                                    data: data,
+                                    response: null,
+                                };
+                                const requestClone = { ...request };
+                                waitForHookFns(request).then(() => {
+                                    waitForRequestKeys(request, requestClone).then(() => {
+                                        if (request.abort)
+                                            return;
+                                        ah.originalMethods.open(request.method, request.url, ...ah.openArgs);
+                                        for (const header in request.headers) {
+                                            ah.originalMethods.setRequestHeader(header, request.headers[header]);
+                                        }
+                                        data = request.data;
+                                        xhr.addEventListener("ajaxHooker_responseReady", (e) => {
+                                            try {
+                                                if (typeof request.response === "function") {
+                                                    const arg = {
+                                                        finalUrl: xhr.responseURL,
+                                                        status: xhr.status,
+                                                        responseHeaders: {},
+                                                    };
+                                                    for (const line of xhr
+                                                        .getAllResponseHeaders()
+                                                        .trim()
+                                                        .split(/[\r\n]+/)) {
+                                                        const parts = line.split(/:\s*/);
+                                                        if (parts.length === 2) {
+                                                            const lheader = parts[0].toLowerCase();
+                                                            if (arg.responseHeaders[lheader]) {
+                                                                arg.responseHeaders[lheader] += ", " + parts[1];
+                                                            }
+                                                            else {
+                                                                arg.responseHeaders[lheader] = parts[1];
+                                                            }
+                                                        }
+                                                    }
+                                                    xhrResponses.forEach((prop) => {
+                                                        defineProp(arg, prop, () => {
+                                                            return (arg[prop] = ah.originalGetters[prop]());
+                                                        }, (val) => {
+                                                            delete arg[prop];
+                                                            arg[prop] = val;
+                                                        });
+                                                        defineProp(xhr, prop, () => {
+                                                            const val = ah.originalGetters[prop]();
+                                                            xhr.dispatchEvent(new CustomEvent("ajaxHooker_readResponse", {
+                                                                detail: { prop, val },
+                                                            }));
+                                                            return val;
+                                                        });
+                                                    });
+                                                    xhr.addEventListener("ajaxHooker_readResponse", (e) => {
+                                                        arg[e.detail.prop] = e.detail.val;
+                                                    });
+                                                    const resPromise = Promise.resolve(request.response(arg)).then(() => {
+                                                        const task = [];
+                                                        xhrResponses.forEach((prop) => {
+                                                            const descriptor = Object.getOwnPropertyDescriptor(arg, prop);
+                                                            if (descriptor && "value" in descriptor) {
+                                                                task.push(Promise.resolve(descriptor.value).then((val) => {
+                                                                    arg[prop] = val;
+                                                                    defineProp(xhr, prop, () => {
+                                                                        xhr.dispatchEvent(new CustomEvent("ajaxHooker_readResponse", {
+                                                                            detail: { prop, val },
+                                                                        }));
+                                                                        return val;
+                                                                    });
+                                                                }, emptyFn));
+                                                            }
+                                                        });
+                                                        return Promise.all(task);
+                                                    }, errorFn);
+                                                    const eventsClone = {};
+                                                    xhrAsyncEvents.forEach((type) => {
+                                                        eventsClone[type] = new Set([...ah.hookedEvents[type]]);
+                                                        eventsClone["on" + type] = ah.hookedEvents["on" + type];
+                                                    });
+                                                    ah.delegateEvent = (event) => resPromise.then(() => {
+                                                        event.stopImmediatePropagation = fakeEventSIP;
+                                                        eventsClone[event.type].forEach((fn) => !event.ajaxHooker_stopped && fn.call(xhr, event));
+                                                        const onEvent = eventsClone["on" + event.type];
+                                                        typeof onEvent === "function" &&
+                                                            onEvent.call(xhr, event);
+                                                    });
+                                                }
+                                            }
+                                            catch (err) {
+                                                console.error(err);
+                                            }
+                                            ah.delegateEvent(e.detail);
+                                        });
+                                        realSend(data);
+                                    });
+                                });
+                            }
+                            catch (err) {
+                                console.error(err);
+                                realSend(data);
+                            }
+                        };
+                        return xhr;
+                    }
+                    function hookFetchResponse(response, arg, callback) {
+                        fetchResponses.forEach((prop) => {
+                            response[prop] = () => new Promise((resolve, reject) => {
+                                resProto[prop].call(response).then((res) => {
+                                    if (prop in arg) {
+                                        resolve(arg[prop]);
+                                    }
+                                    else {
+                                        try {
+                                            arg[prop] = res;
+                                            Promise.resolve(callback(arg)).then(() => {
+                                                if (prop in arg) {
+                                                    Promise.resolve(arg[prop]).then((val) => resolve((arg[prop] = val)), () => resolve(res));
+                                                }
+                                                else {
+                                                    resolve(res);
+                                                }
+                                            }, errorFn);
+                                        }
+                                        catch (err) {
+                                            console.error(err);
+                                            resolve(res);
+                                        }
+                                    }
+                                }, reject);
+                            });
+                        });
+                    }
+                    function fakeFetch(url, init) {
+                        if (url && typeof url.toString === "function") {
+                            url = url.toString();
+                            init = init || {};
+                            init.method = init.method || "GET";
+                            init.headers = init.headers || {};
+                            if (shouldFilter("fetch", url, init.method))
+                                return realFetch.call(win, url, init);
+                            const request = {
+                                type: "fetch",
+                                url: url,
+                                method: init.method.toUpperCase(),
+                                abort: false,
+                                headers: {},
+                                data: init.body,
+                                response: null,
+                            };
+                            if (toString.call(init.headers) === "[object Headers]") {
+                                for (const [key, val] of init.headers) {
+                                    request.headers[key] = val;
+                                }
+                            }
+                            else {
+                                request.headers = { ...init.headers };
+                            }
+                            const requestClone = { ...request };
+                            return new Promise((resolve, reject) => {
+                                try {
+                                    waitForHookFns(request).then(() => {
+                                        waitForRequestKeys(request, requestClone).then(() => {
+                                            if (request.abort)
+                                                return reject("aborted");
+                                            url = request.url;
+                                            init.method = request.method;
+                                            init.headers = request.headers;
+                                            init.body = request.data;
+                                            realFetch.call(win, url, init).then((response) => {
+                                                if (typeof request.response === "function") {
+                                                    const arg = {
+                                                        finalUrl: response.url,
+                                                        status: response.status,
+                                                        responseHeaders: {},
+                                                    };
+                                                    for (const [key, val] of response.headers) {
+                                                        arg.responseHeaders[key] = val;
+                                                    }
+                                                    hookFetchResponse(response, arg, request.response);
+                                                    response.clone = () => {
+                                                        const resClone = resProto.clone.call(response);
+                                                        hookFetchResponse(resClone, arg, request.response);
+                                                        return resClone;
+                                                    };
+                                                }
+                                                resolve(response);
+                                            }, reject);
+                                        });
+                                    });
+                                }
+                                catch (err) {
+                                    console.error(err);
+                                    return realFetch.call(win, url, init);
+                                }
+                            });
+                        }
+                        else {
+                            return realFetch.call(win, url, init);
+                        }
+                    }
+                    win.XMLHttpRequest = fakeXhr;
+                    Object.keys(realXhr).forEach((key) => (fakeXhr[key] = realXhr[key]));
+                    fakeXhr.prototype = realXhr.prototype;
+                    win.fetch = fakeFetch;
+                    return {
+                        hook: (fn) => hookFns.push(fn),
+                        filter: (arr) => {
+                            filter = Array.isArray(arr) && arr.map(toFilterObj);
+                        },
+                        protect: () => {
+                            readonly(win, "XMLHttpRequest", fakeXhr);
+                            readonly(win, "fetch", fakeFetch);
+                        },
+                        unhook: () => {
+                            writable(win, "XMLHttpRequest", realXhr);
+                            writable(win, "fetch", realFetch);
+                        },
+                    };
+                })();
             };
 
             class GMMenu {
@@ -4216,9 +4203,35 @@ System.register('Utils', [], (function (exports) {
 
             class UtilsDictionary {
                 items;
-                constructor(key, value) {
+                constructor(...args) {
                     this.items = new Map();
-                    if (key != null) {
+                    if (args.length === 1) {
+                        // 数组|对象
+                        const data = args[0];
+                        if (Array.isArray(data)) {
+                            // 数组
+                            // [[1,2], [3,4], ...]
+                            for (let index = 0; index < data.length; index++) {
+                                const item = data[index];
+                                if (Array.isArray(item)) {
+                                    const [key, value] = item;
+                                    this.set(key, value);
+                                }
+                            }
+                        }
+                        else if (typeof data === "object" && data != null) {
+                            // 对象
+                            // {1:2, 3:4}
+                            for (const key in data) {
+                                if (Reflect.has(data, key)) {
+                                    this.set(key, data[key]);
+                                }
+                            }
+                        }
+                    }
+                    else if (args.length === 2) {
+                        // 键、值
+                        const [key, value] = args;
                         this.set(key, value);
                     }
                 }
@@ -4234,7 +4247,7 @@ System.register('Utils', [], (function (exports) {
                 get entries() {
                     const that = this;
                     return function* () {
-                        const itemKeys = Object.keys(that.getItems());
+                        const itemKeys = that.keys();
                         for (const keyName of itemKeys) {
                             yield [keyName, that.get(keyName)];
                         }
@@ -4271,7 +4284,7 @@ System.register('Utils', [], (function (exports) {
                  */
                 set(key, val) {
                     if (key === void 0) {
-                        throw new Error("Utils.Dictionary().set 参数 key 不能为空");
+                        throw new Error("Utils.Dictionary().set 参数 key 不能为undefined");
                     }
                     this.items.set(key, val);
                 }
@@ -4909,403 +4922,401 @@ System.register('Utils', [], (function (exports) {
             const setInterval = (...args) => loadOrReturnBroker().setInterval(...args);
             const setTimeout$1 = (...args) => loadOrReturnBroker().setTimeout(...args);
 
-            /* eslint-disable */
-            // ==UserScript==
-            // @name         ModuleRaid.js
-            // @namespace    http://tampermonkey.net/
-            // @version      6.2.0
-            // @description  检索调用webpackJsonp模块，可指定检索的window
-            // @author       empyrealtear
-            // @license      MIT
-            // @original-script https://github.com/pixeldesu/moduleRaid
-            // ==/UserScript==
-
-
-            /**
-             * Main moduleRaid class
-             * @link https://scriptcat.org/zh-CN/script-show-page/2628
-             */
-            class ModuleRaid {
-                /**
-                 * moduleRaid constructor
-                 *
-                 * @example
-                 * Constructing an instance without any arguments:
-                 * ```ts
-                 * const mR = new ModuleRaid()
-                 * ```
-                 *
-                 * Constructing an instance with the optional `opts` object:
-                 * ```ts
-                 * const mR = new ModuleRaid({ entrypoint: 'webpackChunk_custom_name' })
-                 * ```
-                 *
-                 * @param opts a object containing options to initialize moduleRaid with
-                 *  - **opts:**
-                 *    - _target_: the window object being searched for
-                 *    - _entrypoint_: the Webpack entrypoint present on the global window object
-                 *    - _debug_: whether debug mode is enabled or not
-                 *    - _strict_: whether strict mode is enabled or not
-                 */
-                constructor(opts) {
-                    /**
-                     * A random generated module ID we use for injecting into Webpack
-                     */
-                    this.moduleID = Math.random().toString(36).substring(7);
-                    /**
-                     * An array containing different argument injection methods for
-                     * Webpack (before version 4), and subsequently pulling out methods and modules
-                     * @internal
-                     */
-                    this.functionArguments = [
-                        [
-                            [0],
-                            [
-                                (_e, _t, i) => {
-                                    this.modules = i.c;
-                                    this.constructors = i.m;
-                                    this.get = i;
-                                },
-                            ],
-                        ],
-                        [
-                            [1e3],
-                            {
-                                [this.moduleID]: (_e, _t, i) => {
-                                    this.modules = i.c;
-                                    this.constructors = i.m;
-                                    this.get = i;
-                                },
-                            },
-                            [[this.moduleID]],
-                        ],
-                    ];
-                    /**
-                     * An array containing different argument injection methods for
-                     * Webpack (after version 4), and subsequently pulling out methods and modules
-                     * @internal
-                     */
-                    this.arrayArguments = [
-                        [
-                            [this.moduleID],
-                            {},
-                            (e) => {
-                                const mCac = e.m;
-                                Object.keys(mCac).forEach((mod) => {
-                                    try {
-                                        this.modules[mod] = e(mod);
-                                    }
-                                    catch (err) {
-                                        this.log(`[arrayArguments/1] Failed to require(${mod}) with error:\n${err}\n${err.stack}`);
-                                    }
-                                });
-                                this.get = e;
-                            },
-                        ],
-                        this.functionArguments[1],
-                    ];
-                    /**
-                     * Storage for the modules we extracted from Webpack
-                     */
-                    this.modules = {};
-                    /**
-                     * Storage for the constructors we extracted from Webpack
-                     */
-                    this.constructors = [];
-                    let options = {
-                        target: window,
-                        entrypoint: 'webpackJsonp',
-                        debug: false,
-                        strict: false,
-                    };
-                    if (typeof opts === 'object') {
-                        options = Object.assign(Object.assign({}, options), opts);
-                    }
-                    this.target = options.target;
-                    this.entrypoint = options.entrypoint;
-                    this.debug = options.debug;
-                    this.strict = options.strict;
-                    this.detectEntrypoint();
-                    this.fillModules();
-                    this.replaceGet();
-                    this.setupPushEvent();
-                }
-                /**
-                 * Debug logging method, outputs to the console when {@link ModuleRaid.debug} is true
-                 *
-                 * @param {*} message The message to be logged
-                 * @internal
-                 */
-                log(message) {
-                    if (this.debug) {
-                        console.warn(`[moduleRaid] ${message}`);
-                    }
-                }
-                /**
-                 * Method to set an alternative getter if we weren't able to extract __webpack_require__
-                 * from Webpack
-                 * @internal
-                 */
-                replaceGet() {
-                    if (this.get === null) {
-                        this.get = (key) => this.modules[key];
-                    }
-                }
-                /**
-                 * Method that will try to inject a module into Webpack or get modules
-                 * depending on it's success it might be more or less brute about it
-                 * @internal
-                 */
-                fillModules() {
-                    if (typeof this.target[this.entrypoint] === 'function') {
-                        this.functionArguments.forEach((argument, index) => {
-                            try {
-                                if (this.modules && Object.keys(this.modules).length > 0)
-                                    return;
-                                this.target[this.entrypoint](...argument);
-                            }
-                            catch (err) {
-                                this.log(`moduleRaid.functionArguments[${index}] failed:\n${err}\n${err.stack}`);
-                            }
-                        });
-                    }
-                    else {
-                        this.arrayArguments.forEach((argument, index) => {
-                            try {
-                                if (this.modules && Object.keys(this.modules).length > 0)
-                                    return;
-                                this.target[this.entrypoint].push(argument);
-                            }
-                            catch (err) {
-                                this.log(`Pushing moduleRaid.arrayArguments[${index}] into ${this.entrypoint} failed:\n${err}\n${err.stack}`);
-                            }
-                        });
-                    }
-                    if (this.modules && Object.keys(this.modules).length == 0) {
-                        let moduleEnd = false;
-                        let moduleIterator = 0;
-                        if (typeof this.target[this.entrypoint] != 'function' || !this.target[this.entrypoint]([], [], [moduleIterator])) {
-                            throw Error('Unknown Webpack structure');
-                        }
-                        while (!moduleEnd) {
-                            try {
-                                this.modules[moduleIterator] = this.target[this.entrypoint]([], [], [moduleIterator]);
-                                moduleIterator++;
-                            }
-                            catch (err) {
-                                moduleEnd = true;
-                            }
-                        }
-                    }
-                }
-                /**
-                 * Method to hook into `window[this.entrypoint].push` adding a listener for new
-                 * chunks being pushed into Webpack
-                 *
-                 * @example
-                 * You can listen for newly pushed packages using the `moduleraid:webpack-push` event
-                 * on `document`
-                 *
-                 * ```ts
-                 * document.addEventListener('moduleraid:webpack-push', (e) => {
-                 *   // e.detail contains the arguments push() was called with
-                 *   console.log(e.detail)
-                 * })
-                 * ```
-                 * @internal
-                 */
-                setupPushEvent() {
-                    const originalPush = this.target[this.entrypoint].push;
-                    this.target[this.entrypoint].push = (...args) => {
-                        const result = Reflect.apply(originalPush, this.target[this.entrypoint], args);
-                        document.dispatchEvent(new CustomEvent('moduleraid:webpack-push', { detail: args }));
-                        return result;
-                    };
-                }
-                /**
-                 * Method to try autodetecting a Webpack JSONP entrypoint based on common naming
-                 *
-                 * If the default entrypoint, or the entrypoint that's passed to the moduleRaid constructor
-                 * already matches, the method exits early
-                 *
-                 * If `options.strict` has been set in the constructor and the initial entrypoint cannot
-                 * be found, this method will error, demanding a strictly set entrypoint
-                 * @internal
-                 */
-                detectEntrypoint() {
-                    if (this.target[this.entrypoint] != undefined) {
-                        return;
-                    }
-                    if (this.strict) {
-                        throw Error(`Strict mode is enabled and entrypoint at window.${this.entrypoint} couldn't be found. Please specify the correct one!`);
-                    }
-                    let windowObjects = Object.keys(this.target);
-                    windowObjects = windowObjects
-                        .filter((object) => object.toLowerCase().includes('chunk') || object.toLowerCase().includes('webpack'))
-                        .filter((object) => typeof this.target[object] === 'function' || Array.isArray(this.target[object]));
-                    if (windowObjects.length > 1) {
-                        throw Error(`Multiple possible endpoints have been detected, please create a new moduleRaid instance with a specific one:\n${windowObjects.join(', ')}`);
-                    }
-                    if (windowObjects.length === 0) {
-                        throw Error('No Webpack JSONP entrypoints could be detected');
-                    }
-                    this.log(`Entrypoint has been detected at window.${windowObjects[0]} and set for injection`);
-                    this.entrypoint = windowObjects[0];
-                }
-                /**
-                 * Recursive object-search function for modules
-                 *
-                 * @param object the object to search through
-                 * @param query the query the object keys/values are searched for
-                 * @returns boolean state of `object` containing `query` somewhere in it
-                 * @internal
-                 */
-                searchObject(object, query) {
-                    for (const key in object) {
-                        const value = object[key];
-                        const lowerCaseQuery = query.toLowerCase();
-                        if (typeof value != 'object') {
-                            const lowerCaseKey = key.toString().toLowerCase();
-                            if (lowerCaseKey.includes(lowerCaseQuery))
-                                return true;
-                            if (typeof value != 'object') {
-                                const lowerCaseValue = value.toString().toLowerCase();
-                                if (lowerCaseValue.includes(lowerCaseQuery))
-                                    return true;
-                            }
-                            else {
-                                if (this.searchObject(value, query))
-                                    return true;
-                            }
-                        }
-                    }
-                    return false;
-                }
-                /**
-                 * Method to search through the module object, searching for the fitting content
-                 * if a string is supplied
-                 *
-                 * If query is supplied as a function, everything that returns true when passed
-                 * to the query function will be returned
-                 *
-                 * @example
-                 * With a string as query argument:
-                 * ```ts
-                 * const results = mR.findModule('feature')
-                 * // => Array of module results
-                 * ```
-                 *
-                 * With a function as query argument:
-                 * ```ts
-                 * const results = mR.findModule((module) => { typeof module === 'function' })
-                 * // => Array of module results
-                 * ```
-                 *
-                 * @param query query to search the module list for
-                 * @return a list of modules fitting the query
-                 */
-                findModule(query) {
-                    const results = [];
-                    const modules = Object.keys(this.modules);
-                    if (modules.length === 0) {
-                        throw new Error('There are no modules to search through!');
-                    }
-                    modules.forEach((key) => {
-                        const module = this.modules[key.toString()];
-                        if (module === undefined)
-                            return;
-                        try {
-                            if (typeof query === 'string') {
-                                query = query.toLowerCase();
-                                switch (typeof module) {
-                                    case 'string':
-                                        if (module.toLowerCase().includes(query))
-                                            results.push(module);
-                                        break;
-                                    case 'function':
-                                        if (module.toString().toLowerCase().includes(query))
-                                            results.push(module);
-                                        break;
-                                    case 'object':
-                                        if (this.searchObject(module, query))
-                                            results.push(module);
-                                        break;
-                                }
-                            }
-                            else if (typeof query === 'function') {
-                                if (query(module))
-                                    results.push(module);
-                            }
-                            else {
-                                throw new TypeError(`findModule can only find via string and function, ${typeof query} was passed`);
-                            }
-                        }
-                        catch (err) {
-                            this.log(`There was an error while searching through module '${key}':\n${err}\n${err.stack}`);
-                        }
-                    });
-                    return results;
-                }
-                /**
-                 * Method to search through the constructor array, searching for the fitting content
-                 * if a string is supplied
-                 *
-                 * If query is supplied as a function, everything that returns true when passed
-                 * to the query function will be returned
-                 *
-                 * @example
-                 * With a string as query argument:
-                 * ```ts
-                 * const results = mR.findConstructor('feature')
-                 * // => Array of constructor/module tuples
-                 * ```
-                 *
-                 * With a function as query argument:
-                 * ```ts
-                 * const results = mR.findConstructor((constructor) => { constructor.prototype.value !== undefined })
-                 * // => Array of constructor/module tuples
-                 * ```
-                 *
-                 * Accessing the resulting data:
-                 * ```ts
-                 * // With array destructuring (ES6)
-                 * const [constructor, module] = results[0]
-                 *
-                 * // ...or...
-                 *
-                 * // regular access
-                 * const constructor = results[0][0]
-                 * const module = results[0][1]
-                 * ```
-                 *
-                 * @param query query to search the constructor list for
-                 * @returns a list of constructor/module tuples fitting the query
-                 */
-                findConstructor(query) {
-                    const results = [];
-                    const constructors = Object.keys(this.constructors);
-                    if (constructors.length === 0) {
-                        throw new Error('There are no constructors to search through!');
-                    }
-                    constructors.forEach((key) => {
-                        const constructor = this.constructors[key];
-                        try {
-                            if (typeof query === 'string') {
-                                query = query.toLowerCase();
-                                if (constructor.toString().toLowerCase().includes(query))
-                                    results.push([this.constructors[key], this.modules[key]]);
-                            }
-                            else if (typeof query === 'function') {
-                                if (query(constructor))
-                                    results.push([this.constructors[key], this.modules[key]]);
-                            }
-                        }
-                        catch (err) {
-                            this.log(`There was an error while searching through constructor '${key}':\n${err}\n${err.stack}`);
-                        }
-                    });
-                    return results;
-                }
+            /* eslint-disable */
+            // ==UserScript==
+            // @name         ModuleRaid.js
+            // @namespace    http://tampermonkey.net/
+            // @version      6.2.0
+            // @description  检索调用webpackJsonp模块，可指定检索的window
+            // @author       empyrealtear
+            // @license      MIT
+            // @original-script https://github.com/pixeldesu/moduleRaid
+            // ==/UserScript==
+            /**
+             * Main moduleRaid class
+             * @link https://scriptcat.org/zh-CN/script-show-page/2628
+             */
+            class ModuleRaid {
+                /**
+                 * moduleRaid constructor
+                 *
+                 * @example
+                 * Constructing an instance without any arguments:
+                 * ```ts
+                 * const mR = new ModuleRaid()
+                 * ```
+                 *
+                 * Constructing an instance with the optional `opts` object:
+                 * ```ts
+                 * const mR = new ModuleRaid({ entrypoint: 'webpackChunk_custom_name' })
+                 * ```
+                 *
+                 * @param opts a object containing options to initialize moduleRaid with
+                 *  - **opts:**
+                 *    - _target_: the window object being searched for
+                 *    - _entrypoint_: the Webpack entrypoint present on the global window object
+                 *    - _debug_: whether debug mode is enabled or not
+                 *    - _strict_: whether strict mode is enabled or not
+                 */
+                constructor(opts) {
+                    /**
+                     * A random generated module ID we use for injecting into Webpack
+                     */
+                    this.moduleID = Math.random().toString(36).substring(7);
+                    /**
+                     * An array containing different argument injection methods for
+                     * Webpack (before version 4), and subsequently pulling out methods and modules
+                     * @internal
+                     */
+                    this.functionArguments = [
+                        [
+                            [0],
+                            [
+                                (_e, _t, i) => {
+                                    this.modules = i.c;
+                                    this.constructors = i.m;
+                                    this.get = i;
+                                },
+                            ],
+                        ],
+                        [
+                            [1e3],
+                            {
+                                [this.moduleID]: (_e, _t, i) => {
+                                    this.modules = i.c;
+                                    this.constructors = i.m;
+                                    this.get = i;
+                                },
+                            },
+                            [[this.moduleID]],
+                        ],
+                    ];
+                    /**
+                     * An array containing different argument injection methods for
+                     * Webpack (after version 4), and subsequently pulling out methods and modules
+                     * @internal
+                     */
+                    this.arrayArguments = [
+                        [
+                            [this.moduleID],
+                            {},
+                            (e) => {
+                                const mCac = e.m;
+                                Object.keys(mCac).forEach((mod) => {
+                                    try {
+                                        this.modules[mod] = e(mod);
+                                    }
+                                    catch (err) {
+                                        this.log(`[arrayArguments/1] Failed to require(${mod}) with error:\n${err}\n${err.stack}`);
+                                    }
+                                });
+                                this.get = e;
+                            },
+                        ],
+                        this.functionArguments[1],
+                    ];
+                    /**
+                     * Storage for the modules we extracted from Webpack
+                     */
+                    this.modules = {};
+                    /**
+                     * Storage for the constructors we extracted from Webpack
+                     */
+                    this.constructors = [];
+                    let options = {
+                        target: window,
+                        entrypoint: 'webpackJsonp',
+                        debug: false,
+                        strict: false,
+                    };
+                    if (typeof opts === 'object') {
+                        options = Object.assign(Object.assign({}, options), opts);
+                    }
+                    this.target = options.target;
+                    this.entrypoint = options.entrypoint;
+                    this.debug = options.debug;
+                    this.strict = options.strict;
+                    this.detectEntrypoint();
+                    this.fillModules();
+                    this.replaceGet();
+                    this.setupPushEvent();
+                }
+                /**
+                 * Debug logging method, outputs to the console when {@link ModuleRaid.debug} is true
+                 *
+                 * @param {*} message The message to be logged
+                 * @internal
+                 */
+                log(message) {
+                    if (this.debug) {
+                        console.warn(`[moduleRaid] ${message}`);
+                    }
+                }
+                /**
+                 * Method to set an alternative getter if we weren't able to extract __webpack_require__
+                 * from Webpack
+                 * @internal
+                 */
+                replaceGet() {
+                    if (this.get === null) {
+                        this.get = (key) => this.modules[key];
+                    }
+                }
+                /**
+                 * Method that will try to inject a module into Webpack or get modules
+                 * depending on it's success it might be more or less brute about it
+                 * @internal
+                 */
+                fillModules() {
+                    if (typeof this.target[this.entrypoint] === 'function') {
+                        this.functionArguments.forEach((argument, index) => {
+                            try {
+                                if (this.modules && Object.keys(this.modules).length > 0)
+                                    return;
+                                this.target[this.entrypoint](...argument);
+                            }
+                            catch (err) {
+                                this.log(`moduleRaid.functionArguments[${index}] failed:\n${err}\n${err.stack}`);
+                            }
+                        });
+                    }
+                    else {
+                        this.arrayArguments.forEach((argument, index) => {
+                            try {
+                                if (this.modules && Object.keys(this.modules).length > 0)
+                                    return;
+                                this.target[this.entrypoint].push(argument);
+                            }
+                            catch (err) {
+                                this.log(`Pushing moduleRaid.arrayArguments[${index}] into ${this.entrypoint} failed:\n${err}\n${err.stack}`);
+                            }
+                        });
+                    }
+                    if (this.modules && Object.keys(this.modules).length == 0) {
+                        let moduleEnd = false;
+                        let moduleIterator = 0;
+                        if (typeof this.target[this.entrypoint] != 'function' || !this.target[this.entrypoint]([], [], [moduleIterator])) {
+                            throw Error('Unknown Webpack structure');
+                        }
+                        while (!moduleEnd) {
+                            try {
+                                this.modules[moduleIterator] = this.target[this.entrypoint]([], [], [moduleIterator]);
+                                moduleIterator++;
+                            }
+                            catch (err) {
+                                moduleEnd = true;
+                            }
+                        }
+                    }
+                }
+                /**
+                 * Method to hook into `window[this.entrypoint].push` adding a listener for new
+                 * chunks being pushed into Webpack
+                 *
+                 * @example
+                 * You can listen for newly pushed packages using the `moduleraid:webpack-push` event
+                 * on `document`
+                 *
+                 * ```ts
+                 * document.addEventListener('moduleraid:webpack-push', (e) => {
+                 *   // e.detail contains the arguments push() was called with
+                 *   console.log(e.detail)
+                 * })
+                 * ```
+                 * @internal
+                 */
+                setupPushEvent() {
+                    const originalPush = this.target[this.entrypoint].push;
+                    this.target[this.entrypoint].push = (...args) => {
+                        const result = Reflect.apply(originalPush, this.target[this.entrypoint], args);
+                        document.dispatchEvent(new CustomEvent('moduleraid:webpack-push', { detail: args }));
+                        return result;
+                    };
+                }
+                /**
+                 * Method to try autodetecting a Webpack JSONP entrypoint based on common naming
+                 *
+                 * If the default entrypoint, or the entrypoint that's passed to the moduleRaid constructor
+                 * already matches, the method exits early
+                 *
+                 * If `options.strict` has been set in the constructor and the initial entrypoint cannot
+                 * be found, this method will error, demanding a strictly set entrypoint
+                 * @internal
+                 */
+                detectEntrypoint() {
+                    if (this.target[this.entrypoint] != undefined) {
+                        return;
+                    }
+                    if (this.strict) {
+                        throw Error(`Strict mode is enabled and entrypoint at window.${this.entrypoint} couldn't be found. Please specify the correct one!`);
+                    }
+                    let windowObjects = Object.keys(this.target);
+                    windowObjects = windowObjects
+                        .filter((object) => object.toLowerCase().includes('chunk') || object.toLowerCase().includes('webpack'))
+                        .filter((object) => typeof this.target[object] === 'function' || Array.isArray(this.target[object]));
+                    if (windowObjects.length > 1) {
+                        throw Error(`Multiple possible endpoints have been detected, please create a new moduleRaid instance with a specific one:\n${windowObjects.join(', ')}`);
+                    }
+                    if (windowObjects.length === 0) {
+                        throw Error('No Webpack JSONP entrypoints could be detected');
+                    }
+                    this.log(`Entrypoint has been detected at window.${windowObjects[0]} and set for injection`);
+                    this.entrypoint = windowObjects[0];
+                }
+                /**
+                 * Recursive object-search function for modules
+                 *
+                 * @param object the object to search through
+                 * @param query the query the object keys/values are searched for
+                 * @returns boolean state of `object` containing `query` somewhere in it
+                 * @internal
+                 */
+                searchObject(object, query) {
+                    for (const key in object) {
+                        const value = object[key];
+                        const lowerCaseQuery = query.toLowerCase();
+                        if (typeof value != 'object') {
+                            const lowerCaseKey = key.toString().toLowerCase();
+                            if (lowerCaseKey.includes(lowerCaseQuery))
+                                return true;
+                            if (typeof value != 'object') {
+                                const lowerCaseValue = value.toString().toLowerCase();
+                                if (lowerCaseValue.includes(lowerCaseQuery))
+                                    return true;
+                            }
+                            else {
+                                if (this.searchObject(value, query))
+                                    return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+                /**
+                 * Method to search through the module object, searching for the fitting content
+                 * if a string is supplied
+                 *
+                 * If query is supplied as a function, everything that returns true when passed
+                 * to the query function will be returned
+                 *
+                 * @example
+                 * With a string as query argument:
+                 * ```ts
+                 * const results = mR.findModule('feature')
+                 * // => Array of module results
+                 * ```
+                 *
+                 * With a function as query argument:
+                 * ```ts
+                 * const results = mR.findModule((module) => { typeof module === 'function' })
+                 * // => Array of module results
+                 * ```
+                 *
+                 * @param query query to search the module list for
+                 * @return a list of modules fitting the query
+                 */
+                findModule(query) {
+                    const results = [];
+                    const modules = Object.keys(this.modules);
+                    if (modules.length === 0) {
+                        throw new Error('There are no modules to search through!');
+                    }
+                    modules.forEach((key) => {
+                        const module = this.modules[key.toString()];
+                        if (module === undefined)
+                            return;
+                        try {
+                            if (typeof query === 'string') {
+                                query = query.toLowerCase();
+                                switch (typeof module) {
+                                    case 'string':
+                                        if (module.toLowerCase().includes(query))
+                                            results.push(module);
+                                        break;
+                                    case 'function':
+                                        if (module.toString().toLowerCase().includes(query))
+                                            results.push(module);
+                                        break;
+                                    case 'object':
+                                        if (this.searchObject(module, query))
+                                            results.push(module);
+                                        break;
+                                }
+                            }
+                            else if (typeof query === 'function') {
+                                if (query(module))
+                                    results.push(module);
+                            }
+                            else {
+                                throw new TypeError(`findModule can only find via string and function, ${typeof query} was passed`);
+                            }
+                        }
+                        catch (err) {
+                            this.log(`There was an error while searching through module '${key}':\n${err}\n${err.stack}`);
+                        }
+                    });
+                    return results;
+                }
+                /**
+                 * Method to search through the constructor array, searching for the fitting content
+                 * if a string is supplied
+                 *
+                 * If query is supplied as a function, everything that returns true when passed
+                 * to the query function will be returned
+                 *
+                 * @example
+                 * With a string as query argument:
+                 * ```ts
+                 * const results = mR.findConstructor('feature')
+                 * // => Array of constructor/module tuples
+                 * ```
+                 *
+                 * With a function as query argument:
+                 * ```ts
+                 * const results = mR.findConstructor((constructor) => { constructor.prototype.value !== undefined })
+                 * // => Array of constructor/module tuples
+                 * ```
+                 *
+                 * Accessing the resulting data:
+                 * ```ts
+                 * // With array destructuring (ES6)
+                 * const [constructor, module] = results[0]
+                 *
+                 * // ...or...
+                 *
+                 * // regular access
+                 * const constructor = results[0][0]
+                 * const module = results[0][1]
+                 * ```
+                 *
+                 * @param query query to search the constructor list for
+                 * @returns a list of constructor/module tuples fitting the query
+                 */
+                findConstructor(query) {
+                    const results = [];
+                    const constructors = Object.keys(this.constructors);
+                    if (constructors.length === 0) {
+                        throw new Error('There are no constructors to search through!');
+                    }
+                    constructors.forEach((key) => {
+                        const constructor = this.constructors[key];
+                        try {
+                            if (typeof query === 'string') {
+                                query = query.toLowerCase();
+                                if (constructor.toString().toLowerCase().includes(query))
+                                    results.push([this.constructors[key], this.modules[key]]);
+                            }
+                            else if (typeof query === 'function') {
+                                if (query(constructor))
+                                    results.push([this.constructors[key], this.modules[key]]);
+                            }
+                        }
+                        catch (err) {
+                            this.log(`There was an error while searching through constructor '${key}':\n${err}\n${err.stack}`);
+                        }
+                    });
+                    return results;
+                }
             }
 
             class DOMUtils {
@@ -5477,7 +5488,7 @@ System.register('Utils', [], (function (exports) {
             }
             const domUtils = new DOMUtils();
 
-            const version = "2.9.3";
+            const version = "2.9.5";
 
             class Utils {
                 windowApi;