@whitesev/utils 2.5.6 → 2.5.8

package/dist/index.umd.js

@@ -249,7 +249,7 @@
                 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("=");
@@ -1283,14 +1283,14 @@
                     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,
                 });
             }
         }
@@ -2418,13 +2418,13 @@
                         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转为字符串
@@ -2536,30 +2536,30 @@
          * 默认配置
          */
         #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() { },
@@ -3043,7 +3043,7 @@
                             success: false,
                             code: that.#statusCode.getFailed.code,
                             msg: that.#statusCode.getFailed.msg,
-                            data: void 0,
+                            data: undefined,
                         });
                     }
                     else {
@@ -3053,7 +3053,7 @@
                             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,
@@ -3080,7 +3080,7 @@
                                 success: false,
                                 code: that.#statusCode.getFailed.code,
                                 msg: that.#statusCode.getFailed.msg,
-                                data: void 0,
+                                data: undefined,
                                 event: event,
                             });
                         };
@@ -3660,7 +3660,7 @@
                 context = __context__ || this;
                 let result = executeTryCatch(callbackFunction, handleError, context);
                 // @ts-ignore
-                return result !== void 0 ? result : TryCatchCore;
+                return result !== undefined ? result : TryCatchCore;
             },
         };
         /**
@@ -3671,7 +3671,7 @@
          * @returns 如果函数有返回值，则返回该返回值；否则返回 undefined。
          */
         function executeTryCatch(callback, handleErrorFunc, funcThis) {
-            let result = void 0;
+            let result = undefined;
             try {
                 if (typeof callback === "string") {
                     (function () {
@@ -3739,7 +3739,7 @@
          */
         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);
@@ -3754,7 +3754,7 @@
          * @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);
@@ -4139,13 +4139,411 @@
         }
     }
 
+    // ==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 Utils {
         windowApi;
         constructor(option) {
             this.windowApi = new WindowApi(option);
         }
         /** 版本号 */
-        version = "2024.12.25";
+        version = "2025.1.11";
         addStyle(cssText) {
             if (typeof cssText !== "string") {
                 throw new Error("Utils.addStyle 参数cssText 必须为String类型");
@@ -4368,8 +4766,8 @@
         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 ? [] : {};
@@ -5815,36 +6213,36 @@
                      * + 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,
             };
@@ -6419,7 +6817,7 @@
             }
             return new Promise((resolve) => {
                 setTimeout(() => {
-                    resolve(void 0);
+                    resolve(undefined);
                 }, delayTime);
             });
         }
@@ -6759,9 +7157,42 @@
                 await UtilsContext.tryCatch(index, item).run(handleFunc);
             }));
         }
+        wait(checkFn, timeout, parent) {
+            const UtilsContext = this;
+            let __timeout__ = typeof timeout === "number" ? timeout : 0;
+            return new Promise((resolve) => {
+                let observer = UtilsContext.mutationObserver(parent || UtilsContext.windowApi.document, {
+                    config: {
+                        subtree: true,
+                        childList: true,
+                        attributes: true,
+                    },
+                    immediate: true,
+                    callback(mutations, __observer__) {
+                        let result = checkFn();
+                        if (result.success) {
+                            // 取消观察器
+                            if (typeof __observer__?.disconnect === "function") {
+                                __observer__.disconnect();
+                            }
+                            resolve(result.data);
+                        }
+                    },
+                });
+                if (__timeout__ > 0) {
+                    setTimeout(() => {
+                        // 取消观察器
+                        if (typeof observer?.disconnect === "function") {
+                            observer.disconnect();
+                        }
+                        resolve(null);
+                    }, __timeout__);
+                }
+            });
+        }
         waitNode(...args) {
             // 过滤掉undefined
-            args = args.filter((arg) => arg !== void 0);
+            args = args.filter((arg) => arg !== undefined);
             let UtilsContext = this;
             // 选择器
             let selector = args[0];
@@ -6769,8 +7200,10 @@
             let parent = UtilsContext.windowApi.document;
             // 超时时间
             let timeout = 0;
-            if (typeof args[0] !== "string" && !Array.isArray(args[0])) {
-                throw new TypeError("Utils.waitNode 第一个参数必须是string|string[]");
+            if (typeof args[0] !== "string" &&
+                !Array.isArray(args[0]) &&
+                typeof args[0] !== "function") {
+                throw new TypeError("Utils.waitNode 第一个参数必须是string|string[]|Function");
             }
             if (args.length === 1) ;
             else if (args.length === 2) {
@@ -6810,57 +7243,45 @@
             else {
                 throw new TypeError("Utils.waitNode 参数个数错误");
             }
-            return new Promise((resolve) => {
-                function getNode() {
-                    if (Array.isArray(selector)) {
-                        let result = [];
-                        for (let index = 0; index < selector.length; index++) {
-                            let node = parent.querySelector(selector[index]);
-                            if (node) {
-                                result.push(node);
-                            }
-                        }
-                        if (result.length === selector.length) {
-                            return result;
+            function getNode() {
+                if (Array.isArray(selector)) {
+                    let result = [];
+                    for (let index = 0; index < selector.length; index++) {
+                        let node = parent.querySelector(selector[index]);
+                        if (node) {
+                            result.push(node);
                         }
                     }
-                    else {
-                        return parent.querySelector(selector);
+                    if (result.length === selector.length) {
+                        return result;
                     }
                 }
-                var observer = UtilsContext.mutationObserver(parent, {
-                    config: {
-                        subtree: true,
-                        childList: true,
-                        attributes: true,
-                    },
-                    callback() {
-                        let node = getNode();
-                        if (node) {
-                            // 取消观察器
-                            if (typeof observer?.disconnect === "function") {
-                                observer.disconnect();
-                            }
-                            resolve(node);
-                            return;
-                        }
-                    },
-                    immediate: true,
-                });
-                if (timeout > 0) {
-                    setTimeout(() => {
-                        // 取消观察器
-                        if (typeof observer?.disconnect === "function") {
-                            observer.disconnect();
-                        }
-                        resolve(null);
-                    }, timeout);
+                else if (typeof selector === "function") {
+                    return selector();
                 }
-            });
+                else {
+                    return parent.querySelector(selector);
+                }
+            }
+            return UtilsContext.wait(() => {
+                let node = getNode();
+                if (node) {
+                    return {
+                        success: true,
+                        data: node,
+                    };
+                }
+                else {
+                    return {
+                        success: false,
+                        data: node,
+                    };
+                }
+            }, timeout, parent);
         }
         waitAnyNode(...args) {
             // 过滤掉undefined
-            args = args.filter((arg) => arg !== void 0);
+            args = args.filter((arg) => arg !== undefined);
             let UtilsContext = this;
             // 选择器
             let selectorList = args[0];
@@ -6916,7 +7337,7 @@
         }
         waitNodeList(...args) {
             // 过滤掉undefined
-            args = args.filter((arg) => arg !== void 0);
+            args = args.filter((arg) => arg !== undefined);
             let UtilsContext = this;
             // 选择器数组
             let selector = args[0];
@@ -6965,61 +7386,45 @@
             else {
                 throw new TypeError("Utils.waitNodeList 参数个数错误");
             }
-            return new Promise((resolve) => {
-                function getNodeList() {
-                    if (Array.isArray(selector)) {
-                        let result = [];
-                        for (let index = 0; index < selector.length; index++) {
-                            let nodeList = parent.querySelectorAll(selector[index]);
-                            if (nodeList.length) {
-                                result.push(nodeList);
-                            }
-                        }
-                        if (result.length === selector.length) {
-                            return result;
-                        }
-                    }
-                    else {
-                        let nodeList = parent.querySelectorAll(selector);
+            function getNodeList() {
+                if (Array.isArray(selector)) {
+                    let result = [];
+                    for (let index = 0; index < selector.length; index++) {
+                        let nodeList = parent.querySelectorAll(selector[index]);
                         if (nodeList.length) {
-                            return nodeList;
+                            result.push(nodeList);
                         }
                     }
+                    if (result.length === selector.length) {
+                        return result;
+                    }
                 }
-                var observer = UtilsContext.mutationObserver(parent, {
-                    config: {
-                        subtree: true,
-                        childList: true,
-                        attributes: true,
-                    },
-                    callback() {
-                        let node = getNodeList();
-                        if (node) {
-                            // 取消观察器
-                            try {
-                                observer.disconnect();
-                            }
-                            catch (error) { }
-                            resolve(node);
-                            return;
-                        }
-                    },
-                    immediate: true,
-                });
-                if (timeout > 0) {
-                    setTimeout(() => {
-                        // 取消观察器
-                        if (typeof observer?.disconnect === "function") {
-                            observer.disconnect();
-                        }
-                        resolve(null);
-                    }, timeout);
+                else {
+                    let nodeList = parent.querySelectorAll(selector);
+                    if (nodeList.length) {
+                        return nodeList;
+                    }
                 }
-            });
+            }
+            return UtilsContext.wait(() => {
+                let node = getNodeList();
+                if (node) {
+                    return {
+                        success: true,
+                        data: node,
+                    };
+                }
+                else {
+                    return {
+                        success: false,
+                        data: node,
+                    };
+                }
+            }, timeout, parent);
         }
         waitAnyNodeList(...args) {
             // 过滤掉undefined
-            args = args.filter((arg) => arg !== void 0);
+            args = args.filter((arg) => arg !== undefined);
             let UtilsContext = this;
             // 选择器数组
             let selectorList = args[0];
@@ -7317,6 +7722,7 @@
          * > "测试"
          */
         Vue = Vue;
+        ModuleRaid = ModuleRaid;
     }
     let utils = new Utils();