@whitesev/utils 2.5.7 → 2.5.9

package/dist/index.cjs.js

@@ -245,7 +245,7 @@ class UtilsGMCookie {
             throw new TypeError("Utils.GMCookie.get 参数cookieName 必须为字符串");
         }
         let cookies = this.windowApi.document.cookie.split(";");
-        let findValue = void 0;
+        let findValue = undefined;
         for (const cookieItem of cookies) {
             let item = cookieItem.trim();
             let itemSplit = item.split("=");
@@ -1279,14 +1279,14 @@ class GMMenu {
                 const option = menuOption[index];
                 this.MenuHandle.$data.data.push({
                     data: option,
-                    id: void 0,
+                    id: undefined,
                 });
             }
         }
         else {
             this.MenuHandle.$data.data.push({
                 data: menuOption,
-                id: void 0,
+                id: undefined,
             });
         }
     }
@@ -2414,13 +2414,13 @@ class Httpx {
                     status: fetchResponse.status,
                     statusText: fetchResponse.statusText,
                     // @ts-ignore
-                    response: void 0,
+                    response: undefined,
                     responseFetchHeaders: fetchResponse.headers,
                     responseHeaders: "",
                     // @ts-ignore
-                    responseText: void 0,
+                    responseText: undefined,
                     responseType: option.responseType,
-                    responseXML: void 0,
+                    responseXML: undefined,
                 };
                 Object.assign(httpxResponse, option.context || {});
                 // 把headers转为字符串
@@ -2532,30 +2532,30 @@ class Httpx {
      * 默认配置
      */
     #defaultDetails = {
-        url: void 0,
+        url: undefined,
         timeout: 5000,
         async: false,
-        responseType: void 0,
-        headers: void 0,
-        data: void 0,
-        redirect: void 0,
-        cookie: void 0,
-        cookiePartition: void 0,
-        binary: void 0,
-        nocache: void 0,
-        revalidate: void 0,
-        context: void 0,
-        overrideMimeType: void 0,
-        anonymous: void 0,
-        fetch: void 0,
-        fetchInit: void 0,
+        responseType: undefined,
+        headers: undefined,
+        data: undefined,
+        redirect: undefined,
+        cookie: undefined,
+        cookiePartition: undefined,
+        binary: undefined,
+        nocache: undefined,
+        revalidate: undefined,
+        context: undefined,
+        overrideMimeType: undefined,
+        anonymous: undefined,
+        fetch: undefined,
+        fetchInit: undefined,
         allowInterceptConfig: {
             beforeRequest: true,
             afterResponseSuccess: true,
             afterResponseError: true,
         },
-        user: void 0,
-        password: void 0,
+        user: undefined,
+        password: undefined,
         onabort() { },
         onerror() { },
         ontimeout() { },
@@ -3039,7 +3039,7 @@ class indexedDB {
                         success: false,
                         code: that.#statusCode.getFailed.code,
                         msg: that.#statusCode.getFailed.msg,
-                        data: void 0,
+                        data: undefined,
                     });
                 }
                 else {
@@ -3049,7 +3049,7 @@ class indexedDB {
                         let result = target.result;
                         /* result 返回的是 {key: string, value: any} */
                         /* 键值对存储 */
-                        let data = result ? result.value : void 0;
+                        let data = result ? result.value : undefined;
                         if (data == null) {
                             resolve({
                                 success: true,
@@ -3076,7 +3076,7 @@ class indexedDB {
                             success: false,
                             code: that.#statusCode.getFailed.code,
                             msg: that.#statusCode.getFailed.msg,
-                            data: void 0,
+                            data: undefined,
                             event: event,
                         });
                     };
@@ -3656,7 +3656,7 @@ const TryCatch = function (...args) {
             context = __context__ || this;
             let result = executeTryCatch(callbackFunction, handleError, context);
             // @ts-ignore
-            return result !== void 0 ? result : TryCatchCore;
+            return result !== undefined ? result : TryCatchCore;
         },
     };
     /**
@@ -3667,7 +3667,7 @@ const TryCatch = function (...args) {
      * @returns 如果函数有返回值，则返回该返回值；否则返回 undefined。
      */
     function executeTryCatch(callback, handleErrorFunc, funcThis) {
-        let result = void 0;
+        let result = undefined;
         try {
             if (typeof callback === "string") {
                 (function () {
@@ -3735,7 +3735,7 @@ class UtilsDictionary {
      */
     getStartsWith(key) {
         let allKeys = this.keys();
-        let result = void 0;
+        let result = undefined;
         for (const keyName of allKeys) {
             if (String(keyName).startsWith(String(key))) {
                 result = this.get(keyName);
@@ -3750,7 +3750,7 @@ class UtilsDictionary {
      * @param val 值，默认为""
      */
     set(key, val) {
-        if (key === void 0) {
+        if (key === undefined) {
             throw new Error("Utils.Dictionary().set 参数 key 不能为空");
         }
         Reflect.set(this.items, key, val);
@@ -4135,13 +4135,859 @@ class Vue {
     }
 }
 
+// ==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;
+    }
+}
+
+// ==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 Utils {
     windowApi;
     constructor(option) {
         this.windowApi = new WindowApi(option);
     }
     /** 版本号 */
-    version = "2025.1.1";
+    version = "2025.1.11";
     addStyle(cssText) {
         if (typeof cssText !== "string") {
             throw new Error("Utils.addStyle 参数cssText 必须为String类型");
@@ -4261,10 +5107,18 @@ class Utils {
      * ajax劫持库，支持xhr和fetch劫持。
      * + 来源：https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
      * + 作者：cxxjackie
-     * + 版本：1.4.1
+     * + 版本：1.4.3
      * + 文档：https://scriptcat.org/zh-CN/script-show-page/637/
+     * @param useOldVersion 是否使用旧版本，默认false
      */
-    ajaxHooker = AjaxHooker;
+    ajaxHooker = (useOldVersion = false) => {
+        if (useOldVersion) {
+            return AjaxHooker1_2_4();
+        }
+        else {
+            return AjaxHooker();
+        }
+    };
     canvasClickByPosition(canvasElement, clientX = 0, clientY = 0, view = globalThis) {
         if (!(canvasElement instanceof HTMLCanvasElement)) {
             throw new Error("Utils.canvasClickByPosition 参数canvasElement必须是canvas元素");
@@ -4364,8 +5218,8 @@ class Utils {
     ColorConversion = ColorConversion;
     deepClone(obj) {
         let UtilsContext = this;
-        if (obj === void 0)
-            return void 0;
+        if (obj === undefined)
+            return undefined;
         if (obj === null)
             return null;
         let clone = obj instanceof Array ? [] : {};
@@ -5811,36 +6665,36 @@ class Utils {
                  * + true 监听以 target 为根节点的整个子树。包括子树中所有节点的属性，而不仅仅是针对 target
                  * + false (默认) 不生效
                  */
-                subtree: void 0,
+                subtree: undefined,
                 /**
                  * + true 监听 target 节点中发生的节点的新增与删除（同时，如果 subtree 为 true，会针对整个子树生效）
                  * + false (默认) 不生效
                  */
-                childList: void 0,
+                childList: undefined,
                 /**
                  * + true 观察所有监听的节点属性值的变化。默认值为 true，当声明了 attributeFilter 或 attributeOldValue
                  * + false (默认) 不生效
                  */
-                attributes: void 0,
+                attributes: undefined,
                 /**
                  * 一个用于声明哪些属性名会被监听的数组。如果不声明该属性，所有属性的变化都将触发通知
                  */
-                attributeFilter: void 0,
+                attributeFilter: undefined,
                 /**
                  * + true 记录上一次被监听的节点的属性变化；可查阅 MutationObserver 中的 Monitoring attribute values 了解关于观察属性变化和属性值记录的详情
                  * + false (默认) 不生效
                  */
-                attributeOldValue: void 0,
+                attributeOldValue: undefined,
                 /**
                  * + true 监听声明的 target 节点上所有字符的变化。默认值为 true，如果声明了 characterDataOldValue
                  * + false (默认) 不生效
                  */
-                characterData: void 0,
+                characterData: undefined,
                 /**
                  * + true 记录前一个被监听的节点中发生的文本变化
                  * + false (默认) 不生效
                  */
-                characterDataOldValue: void 0,
+                characterDataOldValue: undefined,
             },
             immediate: false,
         };
@@ -6415,7 +7269,7 @@ class Utils {
         }
         return new Promise((resolve) => {
             setTimeout(() => {
-                resolve(void 0);
+                resolve(undefined);
             }, delayTime);
         });
     }
@@ -6790,7 +7644,7 @@ class Utils {
     }
     waitNode(...args) {
         // 过滤掉undefined
-        args = args.filter((arg) => arg !== void 0);
+        args = args.filter((arg) => arg !== undefined);
         let UtilsContext = this;
         // 选择器
         let selector = args[0];
@@ -6879,7 +7733,7 @@ class Utils {
     }
     waitAnyNode(...args) {
         // 过滤掉undefined
-        args = args.filter((arg) => arg !== void 0);
+        args = args.filter((arg) => arg !== undefined);
         let UtilsContext = this;
         // 选择器
         let selectorList = args[0];
@@ -6935,7 +7789,7 @@ class Utils {
     }
     waitNodeList(...args) {
         // 过滤掉undefined
-        args = args.filter((arg) => arg !== void 0);
+        args = args.filter((arg) => arg !== undefined);
         let UtilsContext = this;
         // 选择器数组
         let selector = args[0];
@@ -7022,7 +7876,7 @@ class Utils {
     }
     waitAnyNodeList(...args) {
         // 过滤掉undefined
-        args = args.filter((arg) => arg !== void 0);
+        args = args.filter((arg) => arg !== undefined);
         let UtilsContext = this;
         // 选择器数组
         let selectorList = args[0];
@@ -7320,6 +8174,7 @@ class Utils {
      * > "测试"
      */
     Vue = Vue;
+    ModuleRaid = ModuleRaid;
 }
 let utils = new Utils();