@whitesev/utils 2.9.4 → 2.9.5

package/dist/index.esm.js

@@ -1,7 +1,7 @@
 class ColorConversion {
     /**
      * 判断是否是16进制颜色
-     * @param str
+     * @param str 十六进制颜色，如`#000000`
      */
     isHex(str) {
         if (typeof str !== "string") {
@@ -16,8 +16,8 @@ class ColorConversion {
      * 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)) {
@@ -29,16 +29,16 @@ class ColorConversion {
     }
     /**
      * 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);
@@ -47,9 +47,10 @@ class ColorConversion {
     }
     /**
      * rgb转hex
-     * @param redValue
-     * @param greenValue
-     * @param blueValue
+     * @param redValue 红色值
+     * @param greenValue 绿色值
+     * @param blueValue 蓝色值
+     * @returns hex
      */
     rgbToHex(redValue, greenValue, blueValue) {
         /* 验证输入的rgb值是否合法 */
@@ -66,30 +67,36 @@ class ColorConversion {
     }
     /**
      * 获取颜色变暗或亮
-     * @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]);
@@ -711,1001 +718,981 @@ class UtilsGMCookie {
     }
 }
 
-/* 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 {
@@ -4930,403 +4917,401 @@ const clearTimeout$1 = (timerId) => loadOrReturnBroker().clearTimeout(timerId);
 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 {
@@ -5498,7 +5483,7 @@ class DOMUtils {
 }
 const domUtils = new DOMUtils();
 
-const version = "2.9.4";
+const version = "2.9.5";
 
 class Utils {
     windowApi;