@whitesev/utils 2.5.7 → 2.5.9

package/dist/index.system.js

@@ -248,7 +248,7 @@ System.register('Utils', [], (function (exports) {
                         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("=");
@@ -1282,14 +1282,14 @@ System.register('Utils', [], (function (exports) {
                             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,
                         });
                     }
                 }
@@ -2417,13 +2417,13 @@ System.register('Utils', [], (function (exports) {
                                 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转为字符串
@@ -2535,30 +2535,30 @@ System.register('Utils', [], (function (exports) {
                  * 默认配置
                  */
                 #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() { },
@@ -3042,7 +3042,7 @@ System.register('Utils', [], (function (exports) {
                                     success: false,
                                     code: that.#statusCode.getFailed.code,
                                     msg: that.#statusCode.getFailed.msg,
-                                    data: void 0,
+                                    data: undefined,
                                 });
                             }
                             else {
@@ -3052,7 +3052,7 @@ System.register('Utils', [], (function (exports) {
                                     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,
@@ -3079,7 +3079,7 @@ System.register('Utils', [], (function (exports) {
                                         success: false,
                                         code: that.#statusCode.getFailed.code,
                                         msg: that.#statusCode.getFailed.msg,
-                                        data: void 0,
+                                        data: undefined,
                                         event: event,
                                     });
                                 };
@@ -3659,7 +3659,7 @@ System.register('Utils', [], (function (exports) {
                         context = __context__ || this;
                         let result = executeTryCatch(callbackFunction, handleError, context);
                         // @ts-ignore
-                        return result !== void 0 ? result : TryCatchCore;
+                        return result !== undefined ? result : TryCatchCore;
                     },
                 };
                 /**
@@ -3670,7 +3670,7 @@ System.register('Utils', [], (function (exports) {
                  * @returns 如果函数有返回值，则返回该返回值；否则返回 undefined。
                  */
                 function executeTryCatch(callback, handleErrorFunc, funcThis) {
-                    let result = void 0;
+                    let result = undefined;
                     try {
                         if (typeof callback === "string") {
                             (function () {
@@ -3738,7 +3738,7 @@ System.register('Utils', [], (function (exports) {
                  */
                 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);
@@ -3753,7 +3753,7 @@ System.register('Utils', [], (function (exports) {
                  * @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);
@@ -4138,13 +4138,859 @@ System.register('Utils', [], (function (exports) {
                 }
             }
 
+            // ==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类型");
@@ -4264,10 +5110,18 @@ System.register('Utils', [], (function (exports) {
                  * 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元素");
@@ -4367,8 +5221,8 @@ System.register('Utils', [], (function (exports) {
                 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 ? [] : {};
@@ -5814,36 +6668,36 @@ System.register('Utils', [], (function (exports) {
                              * + 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,
                     };
@@ -6418,7 +7272,7 @@ System.register('Utils', [], (function (exports) {
                     }
                     return new Promise((resolve) => {
                         setTimeout(() => {
-                            resolve(void 0);
+                            resolve(undefined);
                         }, delayTime);
                     });
                 }
@@ -6793,7 +7647,7 @@ System.register('Utils', [], (function (exports) {
                 }
                 waitNode(...args) {
                     // 过滤掉undefined
-                    args = args.filter((arg) => arg !== void 0);
+                    args = args.filter((arg) => arg !== undefined);
                     let UtilsContext = this;
                     // 选择器
                     let selector = args[0];
@@ -6882,7 +7736,7 @@ System.register('Utils', [], (function (exports) {
                 }
                 waitAnyNode(...args) {
                     // 过滤掉undefined
-                    args = args.filter((arg) => arg !== void 0);
+                    args = args.filter((arg) => arg !== undefined);
                     let UtilsContext = this;
                     // 选择器
                     let selectorList = args[0];
@@ -6938,7 +7792,7 @@ System.register('Utils', [], (function (exports) {
                 }
                 waitNodeList(...args) {
                     // 过滤掉undefined
-                    args = args.filter((arg) => arg !== void 0);
+                    args = args.filter((arg) => arg !== undefined);
                     let UtilsContext = this;
                     // 选择器数组
                     let selector = args[0];
@@ -7025,7 +7879,7 @@ System.register('Utils', [], (function (exports) {
                 }
                 waitAnyNodeList(...args) {
                     // 过滤掉undefined
-                    args = args.filter((arg) => arg !== void 0);
+                    args = args.filter((arg) => arg !== undefined);
                     let UtilsContext = this;
                     // 选择器数组
                     let selectorList = args[0];
@@ -7323,6 +8177,7 @@ System.register('Utils', [], (function (exports) {
                  * > "测试"
                  */
                 Vue = Vue;
+                ModuleRaid = ModuleRaid;
             }
             let utils = exports("default", new Utils());