@whitesev/utils 2.9.3 → 2.9.5

package/dist/index.umd.js

@@ -7,7 +7,7 @@
     class ColorConversion {
         /**
          * 判断是否是16进制颜色
-         * @param str
+         * @param str 十六进制颜色，如`#000000`
          */
         isHex(str) {
             if (typeof str !== "string") {
@@ -22,8 +22,8 @@
          * 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)) {
@@ -35,16 +35,16 @@
         }
         /**
          * 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);
@@ -53,9 +53,10 @@
         }
         /**
          * rgb转hex
-         * @param redValue
-         * @param greenValue
-         * @param blueValue
+         * @param redValue 红色值
+         * @param greenValue 绿色值
+         * @param blueValue 蓝色值
+         * @returns hex
          */
         rgbToHex(redValue, greenValue, blueValue) {
             /* 验证输入的rgb值是否合法 */
@@ -72,30 +73,36 @@
         }
         /**
          * 获取颜色变暗或亮
-         * @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]);
@@ -717,1001 +724,981 @@
         }
     }
 
-    /* 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 {
@@ -4217,9 +4204,35 @@
 
     class UtilsDictionary {
         items;
-        constructor(key, value) {
+        constructor(...args) {
             this.items = new Map();
-            if (key != null) {
+            if (args.length === 1) {
+                // 数组|对象
+                const data = args[0];
+                if (Array.isArray(data)) {
+                    // 数组
+                    // [[1,2], [3,4], ...]
+                    for (let index = 0; index < data.length; index++) {
+                        const item = data[index];
+                        if (Array.isArray(item)) {
+                            const [key, value] = item;
+                            this.set(key, value);
+                        }
+                    }
+                }
+                else if (typeof data === "object" && data != null) {
+                    // 对象
+                    // {1:2, 3:4}
+                    for (const key in data) {
+                        if (Reflect.has(data, key)) {
+                            this.set(key, data[key]);
+                        }
+                    }
+                }
+            }
+            else if (args.length === 2) {
+                // 键、值
+                const [key, value] = args;
                 this.set(key, value);
             }
         }
@@ -4235,7 +4248,7 @@
         get entries() {
             const that = this;
             return function* () {
-                const itemKeys = Object.keys(that.getItems());
+                const itemKeys = that.keys();
                 for (const keyName of itemKeys) {
                     yield [keyName, that.get(keyName)];
                 }
@@ -4272,7 +4285,7 @@
          */
         set(key, val) {
             if (key === void 0) {
-                throw new Error("Utils.Dictionary().set 参数 key 不能为空");
+                throw new Error("Utils.Dictionary().set 参数 key 不能为undefined");
             }
             this.items.set(key, val);
         }
@@ -4910,403 +4923,401 @@
     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 {
@@ -5478,7 +5489,7 @@
     }
     const domUtils = new DOMUtils();
 
-    const version = "2.9.3";
+    const version = "2.9.5";
 
     class Utils {
         windowApi;