@whitesev/utils 1.0.5 → 1.0.6

package/dist/index.esm.js

@@ -940,2284 +940,2139 @@ const AjaxHooker = function () {
 	})();
 };
 
-/**
- * 
- * @param {UtilsGMMenuConstructorOptions} details 
- */
-const GMMenu = function (details) {
-	const GM_Api = {
-		/**
-		 * 获取存储的数据
-		 * @type {GM_getValue}
-		 */
-		getValue: details.GM_getValue,
-		/**
-		 * 设置数据到存储
-		 * @type {GM_setValue}
-		 */
-		setValue: details.GM_setValue,
-		/**
-		 * 注册菜单
-		 * @type {GM_registerMenuCommand}
-		 */
-		registerMenuCommand: details.GM_registerMenuCommand,
-		/**
-		 * 卸载菜单
-		 * @type {GM_unregisterMenuCommand}
-		 */
-		unregisterMenuCommand: details.GM_unregisterMenuCommand,
-	};
-	for (const keyName of Object.keys(GM_Api)) {
-		if (typeof GM_Api[keyName] !== "function") {
-			throw new Error(
-				`Utils.GM_Menu 请在脚本开头加上 @grant  ${keyName}，且传入该对象`
-			);
-		}
-	}
-	/** 上下文 */
-	const context = this;
-
-	const MenuHandle = {
-		$data: {
-			/**
-			 * 菜单数据
-			 * @type {UtilsGMMenuOptionData[]}
-			 */
-			data: [],
-			/**
-			 * 本地存储的键名
-			 */
-			key: "GM_Menu_Local_Map",
-		},
-		$default: {
-			/** 自动刷新网页，默认为true */
-			autoReload:
-				typeof details.autoReload === "boolean" ? details.autoReload : true,
-			/**
-			 * 菜单isStoreValue的默认值
-			 */
-			isStoreValue: true,
-		},
-		$emoji: {
-			/**
-			 * 菜单enable为true的emoji
-			 */
-			success: "✅",
-			/**
-			 * 菜单enable为false的emoji
-			 */
-			error: "❌",
-		},
-		/**
-		 * 初始化数据
-		 */
-		init() {
-			for (let index = 0; index < this.$data.data.length; index++) {
-				let menuOption = this.$data.data[index]["data"];
-				menuOption.enable = Boolean(
-					this.getLocalMenuData(menuOption.key, menuOption.enable)
-				);
-				if (typeof menuOption.showText !== "function") {
-					menuOption.showText = (menuText, menuEnable) => {
-						if (menuEnable) {
-							return this.$emoji.success + " " + menuText;
-						} else {
-							return this.$emoji.error + " " + menuText;
-						}
-					};
-				}
-			}
-		},
-		/**
-		 * 注册油猴菜单
-		 * @param { ?UtilsGMMenuOptionData[] } menuOptions 如果存在，使用它
-		 */
-		register(menuOptions) {
-			if (menuOptions == null) {
-				throw new TypeError("register菜单数据不能为空");
-			}
-			if (!Array.isArray(menuOptions)) {
-				menuOptions = [menuOptions];
-			}
-			for (let index = 0; index < menuOptions.length; index++) {
-				let cloneMenuOptionData = Utils.deepClone(menuOptions[index].data);
-				const { showText, clickCallBack } =
-					this.handleMenuData(cloneMenuOptionData);
-				let menuId = GM_Api.registerMenuCommand(showText, clickCallBack);
-				menuOptions[index].id = menuId;
-				cloneMenuOptionData.deleteMenu = function () {
-					GM_Api.unregisterMenuCommand(menuId);
-				};
-				Reflect.deleteProperty(menuOptions[index], "handleData");
-				menuOptions[index].handleData = cloneMenuOptionData;
-			}
-		},
-		/**
-		 * 获取本地存储菜单键值
-		 * @param {string} key 键
-		 * @returns {boolean}
-		 */
-		getLocalMenuData(key, defaultValue) {
-			let localData = GM_Api.getValue(this.$data.key, {});
-			if (key in localData) {
-				return localData[key];
-			} else {
-				return defaultValue;
-			}
-		},
-		/**
-		 * 设置本地存储菜单键值
-		 * @param {string} key 键
-		 * @param {boolean} value 值
-		 */
-		setLocalMenuData(key, value) {
-			let localData = GM_Api.getValue(this.$data.key, {});
-			localData[key] = value;
-			GM_Api.setValue(this.$data.key, localData);
-		},
-		/**
-		 * 处理初始化配置
-		 * @param { UtilsGMMenuOption } menuOption
-		 */
-		handleInitDetail(menuOption) {
-			menuOption.enable = Boolean(
-				this.getLocalMenuData(menuOption.key, menuOption.enable)
-			);
-			if (typeof menuOption.showText !== "function") {
-				menuOption.showText = (menuText, menuEnable) => {
-					if (menuEnable) {
-						return this.$emoji.success + " " + menuText;
-					} else {
-						return this.$emoji.error + " " + menuText;
-					}
-				};
-			}
-			return menuOption;
-		},
-		/**
-		 * 对菜单数据进行处理
-		 * @param { UtilsGMMenuOption } menuOption
-		 */
-		handleMenuData(menuOption) {
-			let menuLocalDataItemKey = menuOption.key;
-			/* 菜单默认开启的状态 */
-			let defaultEnable = Boolean(
-				this.getLocalMenuData(menuLocalDataItemKey, menuOption.enable)
-			);
-			/** 油猴菜单上显示的文本 */
-			let showText = menuOption.showText(menuOption.text, defaultEnable);
-			const that = this;
-			({
-				/**
-				 * 菜单的id
-				 */
-				id: menuOption.id,
-				/**
-				 * 点击菜单项后是否应关闭弹出菜单
-				 */
-				autoClose: menuOption.autoClose,
-				/**
-				 * 菜单项的可选访问键
-				 */
-				accessKey: menuOption.accessKey,
-				/**
-				 * 菜单项的鼠标悬浮上的工具提示
-				 */
-				title: menuOption.title,
-			});
-			/* 点击菜单后触发callback后的网页是否刷新 */
-			menuOption.autoReload =
-				typeof menuOption.autoReload !== "boolean"
-					? this.$default.autoReload
-					: menuOption.autoReload;
-			/* 点击菜单后触发callback后的网页是否存储值 */
-			menuOption.isStoreValue =
-				typeof menuOption.isStoreValue !== "boolean"
-					? this.$default.isStoreValue
-					: menuOption.isStoreValue;
-			/**
-			 * 用户点击菜单后的回调函数
-			 * @param {MouseEvent|PointerEvent} event
-			 */
-			function clickCallBack(event) {
-				let localEnable = Boolean(
-					that.getLocalMenuData(menuLocalDataItemKey, defaultEnable)
-				);
-				if (menuOption.isStoreValue) {
-					that.setLocalMenuData(menuLocalDataItemKey, !localEnable);
-				}
-				if (typeof menuOption.callback === "function") {
-					menuOption.callback({
-						key: menuLocalDataItemKey,
-						enable: !localEnable,
-						oldEnable: localEnable,
-						event: event,
-						storeValue(value) {
-							that.setLocalMenuData(menuLocalDataItemKey, value);
-						},
-					});
-				}
-				/* 不刷新网页就刷新菜单 */
-				if (menuOption.autoReload) {
-					window.location.reload();
-				} else {
-					context.update();
-				}
-			}
-
-			return {
-				showText,
-				clickCallBack,
-			};
-		},
-		/**
-		 * 获取目标菜单配置数据
-		 * @param {string} menuKey 菜单-键key
-		 */
-		getMenuData(menuKey) {
-			return this.$data.data.find((item) => item.data.key === menuKey);
-		},
-		/**
-		 * 获取目标菜单配置
-		 * @param {string} menuKey 菜单-键key
-		 */
-		getMenuOption(menuKey) {
-			return this.$data.data.find((item) => item.data.key === menuKey)?.data;
-		},
-		/**
-		 * 获取目标菜单处理后的配置
-		 * @param {string} menuKey 菜单-键key
-		 */
-		getMenuHandledOption(menuKey) {
-			return this.$data.data.find((item) => item.handleData.key === menuKey)
-				?.handleData;
-		},
-	};
-
-	/**
-	 * 新增菜单数据
-	 * @param {UtilsGMMenuOption[]|UtilsGMMenuOption} paramData
-	 */
-	this.add = function (paramData) {
-		if (Array.isArray(paramData)) {
-			for (const _paramData of paramData) {
-				MenuHandle.$data.data.push({
-					data: _paramData,
-					id: void 0,
-				});
-			}
-		} else {
-			MenuHandle.$data.data.push({
-				data: paramData,
-				id: void 0,
-			});
-		}
-		this.update();
-	};
-	/**
-	 * 更新菜单数据
-	 * @param { ?UtilsGMMenuOption[]|UtilsGMMenuOption } options 数据
-	 */
-	this.update = function (options) {
-		/**
-		 * @type {UtilsGMMenuOption[]}
-		 */
-		let optionsList = [];
-		if (Array.isArray(options)) {
-			optionsList = [...optionsList, ...options];
-		} else if (options != null) {
-			optionsList = [...optionsList, options];
-		}
-		optionsList.forEach((item) => {
-			let targetMenu = MenuHandle.getMenuOption(item.key);
-			if (targetMenu) {
-				Object.assign(targetMenu, item);
-			}
-		});
-		MenuHandle.$data.data.forEach((value) => {
-			if (value.handleData) {
-				value.handleData.deleteMenu();
-			}
-		});
-		MenuHandle.init();
-		MenuHandle.register(MenuHandle.$data.data);
-	};
-	/**
-	 * 卸载菜单
-	 * @param {number} menuId 已注册的菜单id
-	 */
-	this.delete = function (menuId) {
-		GM_Api.unregisterMenuCommand(menuId);
-	};
-	/**
-	 * 根据键值获取enable值
-	 * @param {string} menuKey 菜单-键key
-	 * @returns {boolean}
-	 */
-	this.get = function (menuKey) {
-		return this.getEnable(menuKey);
-	};
-	/**
-	 * 根据键值获取enable值
-	 * @param {string} menuKey 菜单-键key
-	 * @returns {boolean}
-	 */
-	this.getEnable = function (menuKey) {
-		return MenuHandle.getMenuHandledOption(menuKey).enable;
-	};
-	/**
-	 * 根据键值获取text值
-	 * @param {string} menuKey 菜单-键key
-	 * @returns {string}
-	 */
-	this.getText = function (menuKey) {
-		return MenuHandle.getMenuHandledOption(menuKey).text;
-	};
-	/**
-	 * 根据键值获取showText函数的值
-	 * @param {string} menuKey 菜单-键key
-	 * @returns {string}
-	 */
-	this.getShowTextValue = function (menuKey) {
-		return MenuHandle.getMenuHandledOption(menuKey).showText(
-			this.getText(menuKey),
-			this.get(menuKey)
-		);
-	};
-	/**
-	 * 获取当前已注册菜单的id
-	 * @param {string} menuKey
-	 * @returns {?number}
-	 */
-	this.getMenuId = function (menuKey) {
-		let result = null;
-		for (let index = 0; index < MenuHandle.$data.data.length; index++) {
-			const optionData = MenuHandle.$data.data[index];
-			if (optionData.handleData.key === menuKey) {
-				result = optionData.id;
-				break;
-			}
-		}
-		return result;
-	};
-	/**
-	 * 根据键值获取accessKey值
-	 * @param {string} menuKey 菜单-键key
-	 * @returns {?string}
-	 */
-	this.getAccessKey = function (menuKey) {
-		return MenuHandle.getMenuHandledOption(menuKey).accessKey;
-	};
-	/**
-	 * 根据键值获取autoClose值
-	 * @param {string} menuKey 菜单-键key
-	 * @returns {?boolean}
-	 */
-	this.getAutoClose = function (menuKey) {
-		return MenuHandle.getMenuHandledOption(menuKey).autoClose;
-	};
-	/**
-	 * 根据键值获取autoReload值
-	 * @param {string} menuKey 菜单-键key
-	 * @returns {boolean}
-	 */
-	this.getAutoReload = function (menuKey) {
-		return MenuHandle.getMenuHandledOption(menuKey).autoReload;
-	};
-	/**
-	 * 根据键值获取callback函数
-	 * @param {string} menuKey 菜单-键key
-	 * @returns {?Function}
-	 */
-	this.getCallBack = function (menuKey) {
-		return MenuHandle.getMenuHandledOption(menuKey).callback;
-	};
-	/**
-	 * 获取当enable为true时默认显示在菜单中前面的emoji图标
-	 * @returns {string}
-	 */
-	this.getEnableTrueEmoji = function () {
-		return MenuHandle.$emoji.success;
-	};
-	/**
-	 * 获取当enable为false时默认显示在菜单中前面的emoji图标
-	 * @returns {string}
-	 */
-	this.getEnableFalseEmoji = function () {
-		return MenuHandle.$emoji.error;
-	};
-	/**
-	 * 获取本地存储的菜单外部的键名
-	 * @param {string} keyName
-	 */
-	this.getLocalStorageKeyName = function () {
-		return MenuHandle.$data.key;
-	};
-	/**
-	 * 设置菜单的值
-	 * @param {string} menuKey 菜单-键key
-	 * @param {any} value 需要设置的值
-	 */
-	this.setValue = function (menuKey, value) {
-		MenuHandle.setLocalMenuData(menuKey, value);
-	};
-	/**
-	 * 设置菜单的值
-	 * @param {string} menuKey 菜单-键key
-	 * @param {boolean} value 需要设置的值
-	 */
-	this.setEnable = function (menuKey, value) {
-		this.setValue(menuKey, Boolean(value));
-	};
-	/**
-	 * 设置当enable为true时默认显示在菜单中前面的emoji图标
-	 * @param {string} emojiString
-	 */
-	this.setEnableTrueEmoji = function (emojiString) {
-		if (typeof emojiString !== "string") {
-			throw new Error("参数emojiString必须是string类型");
-		}
-		MenuHandle.$emoji.success = emojiString;
-	};
-	/**
-	 * 设置当enable为false时默认显示在菜单中前面的emoji图标
-	 * @param {string} emojiString
-	 */
-	this.setEnableFalseEmoji = function (emojiString) {
-		if (typeof emojiString !== "string") {
-			throw new Error("参数emojiString必须是string类型");
-		}
-		MenuHandle.$emoji.error = emojiString;
-	};
-	/**
-	 * 设置本地存储的菜单外部的键名
-	 * @param {string} keyName
-	 */
-	this.setLocalStorageKeyName = function (keyName) {
-		if (typeof keyName !== "string") {
-			throw new Error("参数keyName必须是string类型");
-		}
-		MenuHandle.$data.key = keyName;
-	};
-
-	this.add(details?.data || []);
-};
+class GMMenu {
+    GM_Api = {
+        /**
+         * 获取存储的数据
+         */
+        getValue: GM_getValue,
+        /**
+         * 设置数据到存储
+         */
+        setValue: GM_setValue,
+        /**
+         * 注册菜单
+         */
+        registerMenuCommand: GM_registerMenuCommand,
+        /**
+         * 卸载菜单
+         */
+        unregisterMenuCommand: GM_unregisterMenuCommand,
+    };
+    MenuHandle = {
+        context: this,
+        $data: {
+            /**
+             * 菜单数据
+             */
+            data: [],
+            /**
+             * 本地存储的键名
+             */
+            key: "GM_Menu_Local_Map",
+        },
+        $default: {
+            /** 自动刷新网页，默认为true */
+            autoReload: true,
+            /**
+             * 菜单isStoreValue的默认值
+             */
+            isStoreValue: true,
+        },
+        $emoji: {
+            /**
+             * 菜单enable为true的emoji
+             */
+            success: "✅",
+            /**
+             * 菜单enable为false的emoji
+             */
+            error: "❌",
+        },
+        /**
+         * 初始化数据
+         */
+        init() {
+            for (let index = 0; index < this.$data.data.length; index++) {
+                let menuOption = this.$data.data[index]["data"];
+                menuOption.enable = Boolean(this.getLocalMenuData(menuOption.key, menuOption.enable));
+                if (typeof menuOption.showText !== "function") {
+                    menuOption.showText = (menuText, menuEnable) => {
+                        if (menuEnable) {
+                            return this.$emoji.success + " " + menuText;
+                        }
+                        else {
+                            return this.$emoji.error + " " + menuText;
+                        }
+                    };
+                }
+            }
+        },
+        /**
+         * 注册油猴菜单
+         * @param menuOptions 如果存在，使用它
+         */
+        register(menuOptions) {
+            let that = this;
+            if (menuOptions == null) {
+                throw new TypeError("register菜单数据不能为空");
+            }
+            if (!Array.isArray(menuOptions)) {
+                menuOptions = [menuOptions];
+            }
+            for (let index = 0; index < menuOptions.length; index++) {
+                let cloneMenuOptionData = utils.deepClone(menuOptions[index].data);
+                const { showText, clickCallBack } = this.handleMenuData(cloneMenuOptionData);
+                let menuId = that.context.GM_Api.registerMenuCommand(showText, clickCallBack);
+                menuOptions[index].id = menuId;
+                cloneMenuOptionData.deleteMenu = function () {
+                    that.context.GM_Api.unregisterMenuCommand(menuId);
+                };
+                Reflect.deleteProperty(menuOptions[index], "handleData");
+                menuOptions[index].handleData = cloneMenuOptionData;
+            }
+        },
+        /**
+         * 获取本地存储菜单键值
+         * @param {string} key 键
+         */
+        getLocalMenuData(key, defaultValue) {
+            let localData = this.context.GM_Api.getValue(this.$data.key, {});
+            if (key in localData) {
+                return localData[key];
+            }
+            else {
+                return defaultValue;
+            }
+        },
+        /**
+         * 设置本地存储菜单键值
+         * @param key 键
+         * @param value 值
+         */
+        setLocalMenuData(key, value) {
+            let localData = this.context.GM_Api.getValue(this.$data.key, {});
+            localData[key] = value;
+            this.context.GM_Api.setValue(this.$data.key, localData);
+        },
+        /**
+         * 处理初始化配置
+         * @param menuOption
+         */
+        handleInitDetail(menuOption) {
+            menuOption.enable = Boolean(this.getLocalMenuData(menuOption.key, menuOption.enable));
+            if (typeof menuOption.showText !== "function") {
+                menuOption.showText = (menuText, menuEnable) => {
+                    if (menuEnable) {
+                        return this.$emoji.success + " " + menuText;
+                    }
+                    else {
+                        return this.$emoji.error + " " + menuText;
+                    }
+                };
+            }
+            return menuOption;
+        },
+        /**
+         * 对菜单数据进行处理
+         * @param menuOption
+         */
+        handleMenuData(menuOption) {
+            let that = this;
+            let menuLocalDataItemKey = menuOption.key;
+            /* 菜单默认开启的状态 */
+            let defaultEnable = Boolean(this.getLocalMenuData(menuLocalDataItemKey, menuOption.enable));
+            /** 油猴菜单上显示的文本 */
+            let showText = menuOption.showText(menuOption.text, defaultEnable);
+            ({
+                /**
+                 * 菜单的id
+                 */
+                id: menuOption.id,
+                /**
+                 * 点击菜单项后是否应关闭弹出菜单
+                 */
+                autoClose: menuOption.autoClose,
+                /**
+                 * 菜单项的可选访问键
+                 */
+                accessKey: menuOption.accessKey,
+                /**
+                 * 菜单项的鼠标悬浮上的工具提示
+                 */
+                title: menuOption.title,
+            });
+            /* 点击菜单后触发callback后的网页是否刷新 */
+            menuOption.autoReload =
+                typeof menuOption.autoReload !== "boolean"
+                    ? this.$default.autoReload
+                    : menuOption.autoReload;
+            /* 点击菜单后触发callback后的网页是否存储值 */
+            menuOption.isStoreValue =
+                typeof menuOption.isStoreValue !== "boolean"
+                    ? this.$default.isStoreValue
+                    : menuOption.isStoreValue;
+            /**
+             * 用户点击菜单后的回调函数
+             * @param event
+             */
+            function clickCallBack(event) {
+                let localEnable = Boolean(that.getLocalMenuData(menuLocalDataItemKey, defaultEnable));
+                if (menuOption.isStoreValue) {
+                    that.setLocalMenuData(menuLocalDataItemKey, !localEnable);
+                }
+                if (typeof menuOption.callback === "function") {
+                    menuOption.callback({
+                        key: menuLocalDataItemKey,
+                        enable: !localEnable,
+                        oldEnable: localEnable,
+                        event: event,
+                        storeValue(value) {
+                            that.setLocalMenuData(menuLocalDataItemKey, value);
+                        },
+                    });
+                }
+                /* 不刷新网页就刷新菜单 */
+                if (menuOption.autoReload) {
+                    window.location.reload();
+                }
+                else {
+                    that.context.update();
+                }
+            }
+            return {
+                showText,
+                clickCallBack,
+            };
+        },
+        /**
+         * 获取目标菜单配置数据
+         * @param menuKey 菜单-键key
+         */
+        getMenuData(menuKey) {
+            return this.$data.data.find((item) => item.data.key === menuKey);
+        },
+        /**
+         * 获取目标菜单配置
+         * @param menuKey 菜单-键key
+         */
+        getMenuOption(menuKey) {
+            return this.$data.data.find((item) => item.data.key === menuKey)?.data;
+        },
+        /**
+         * 获取目标菜单处理后的配置
+         * @param menuKey 菜单-键key
+         */
+        getMenuHandledOption(menuKey) {
+            return this.$data.data.find((item) => item.handleData.key === menuKey)
+                ?.handleData;
+        },
+    };
+    constructor(details) {
+        this.GM_Api.getValue = details.GM_getValue;
+        this.GM_Api.setValue = details.GM_setValue;
+        this.GM_Api.registerMenuCommand = details.GM_registerMenuCommand;
+        this.GM_Api.unregisterMenuCommand = details.GM_unregisterMenuCommand;
+        this.MenuHandle.$default.autoReload =
+            typeof details.autoReload === "boolean" ? details.autoReload : true;
+        for (const keyName of Object.keys(this.GM_Api)) {
+            if (typeof this.GM_Api[keyName] !== "function") {
+                throw new Error(`Utils.GM_Menu 请在脚本开头加上 @grant  ${keyName}，且传入该对象`);
+            }
+        }
+        this.add(details?.data || []);
+    }
+    /**
+     * 新增菜单数据
+     * @param paramData
+     */
+    add(paramData) {
+        if (Array.isArray(paramData)) {
+            for (const _paramData of paramData) {
+                // @ts-ignore
+                this.MenuHandle.$data.data.push({
+                    data: _paramData,
+                    id: void 0,
+                });
+            }
+        }
+        else {
+            // @ts-ignore
+            this.MenuHandle.$data.data.push({
+                data: paramData,
+                id: void 0,
+            });
+        }
+        this.update();
+    }
+    /**
+     * 更新菜单数据
+     * @param options 数据
+     */
+    update(options) {
+        let optionsList = [];
+        if (Array.isArray(options)) {
+            optionsList = [...optionsList, ...options];
+        }
+        else if (options != null) {
+            optionsList = [...optionsList, options];
+        }
+        optionsList.forEach((item) => {
+            let targetMenu = this.MenuHandle.getMenuOption(item.key);
+            if (targetMenu) {
+                Object.assign(targetMenu, item);
+            }
+        });
+        this.MenuHandle.$data.data.forEach((value) => {
+            if (value.handleData) {
+                value.handleData.deleteMenu();
+            }
+        });
+        this.MenuHandle.init();
+        this.MenuHandle.register(this.MenuHandle.$data.data);
+    }
+    /**
+     * 卸载菜单
+     * @param menuId 已注册的菜单id
+     */
+    delete(menuId) {
+        this.GM_Api.unregisterMenuCommand(menuId);
+    }
+    /**
+     * 根据键值获取enable值
+     * @param menuKey 菜单-键key
+     */
+    get(menuKey) {
+        return this.getEnable(menuKey);
+    }
+    /**
+     * 根据键值获取enable值
+     * @param menuKey 菜单-键key
+     */
+    getEnable(menuKey) {
+        return this.MenuHandle.getMenuHandledOption(menuKey).enable;
+    }
+    /**
+     * 根据键值获取text值
+     * @param menuKey 菜单-键key
+     */
+    getText(menuKey) {
+        return this.MenuHandle.getMenuHandledOption(menuKey).text;
+    }
+    /**
+     * 根据键值获取showText函数的值
+     * @param menuKey 菜单-键key
+     */
+    getShowTextValue(menuKey) {
+        return this.MenuHandle.getMenuHandledOption(menuKey).showText(this.getText(menuKey), this.get(menuKey));
+    }
+    /**
+     * 获取当前已注册菜单的id
+     * @param menuKey
+     */
+    getMenuId(menuKey) {
+        let result = null;
+        for (let index = 0; index < this.MenuHandle.$data.data.length; index++) {
+            const optionData = this.MenuHandle.$data.data[index];
+            if (optionData.handleData.key === menuKey) {
+                result = optionData.id;
+                break;
+            }
+        }
+        return result;
+    }
+    /**
+     * 根据键值获取accessKey值
+     * @param menuKey 菜单-键key
+     */
+    getAccessKey(menuKey) {
+        return this.MenuHandle.getMenuHandledOption(menuKey)?.accessKey;
+    }
+    /**
+     * 根据键值获取autoClose值
+     * @param menuKey 菜单-键key
+     */
+    getAutoClose(menuKey) {
+        return this.MenuHandle.getMenuHandledOption(menuKey)?.autoClose;
+    }
+    /**
+     * 根据键值获取autoReload值
+     * @param menuKey 菜单-键key
+     */
+    getAutoReload(menuKey) {
+        return this.MenuHandle.getMenuHandledOption(menuKey)?.autoReload;
+    }
+    /**
+     * 根据键值获取callback函数
+     * @param menuKey 菜单-键key
+     */
+    getCallBack(menuKey) {
+        return this.MenuHandle.getMenuHandledOption(menuKey)?.callback;
+    }
+    /**
+     * 获取当enable为true时默认显示在菜单中前面的emoji图标
+     */
+    getEnableTrueEmoji() {
+        return this.MenuHandle.$emoji.success;
+    }
+    /**
+     * 获取当enable为false时默认显示在菜单中前面的emoji图标
+     */
+    getEnableFalseEmoji() {
+        return this.MenuHandle.$emoji.error;
+    }
+    /**
+     * 获取本地存储的菜单外部的键名
+     * @param keyName
+     */
+    getLocalStorageKeyName() {
+        return this.MenuHandle.$data.key;
+    }
+    /**
+     * 设置菜单的值
+     * @param menuKey 菜单-键key
+     * @param value 需要设置的值
+     */
+    setValue(menuKey, value) {
+        this.MenuHandle.setLocalMenuData(menuKey, value);
+    }
+    /**
+     * 设置菜单的值
+     * @param menuKey 菜单-键key
+     * @param value 需要设置的值
+     */
+    setEnable(menuKey, value) {
+        this.setValue(menuKey, Boolean(value));
+    }
+    /**
+     * 设置当enable为true时默认显示在菜单中前面的emoji图标
+     * @param emojiString
+     */
+    setEnableTrueEmoji(emojiString) {
+        if (typeof emojiString !== "string") {
+            throw new Error("参数emojiString必须是string类型");
+        }
+        this.MenuHandle.$emoji.success = emojiString;
+    }
+    /**
+     * 设置当enable为false时默认显示在菜单中前面的emoji图标
+     * @param emojiString
+     */
+    setEnableFalseEmoji(emojiString) {
+        if (typeof emojiString !== "string") {
+            throw new Error("参数emojiString必须是string类型");
+        }
+        this.MenuHandle.$emoji.error = emojiString;
+    }
+    /**
+     * 设置本地存储的菜单外部的键名
+     * @param keyName
+     */
+    setLocalStorageKeyName(keyName) {
+        if (typeof keyName !== "string") {
+            throw new Error("参数keyName必须是string类型");
+        }
+        this.MenuHandle.$data.key = keyName;
+    }
+}
 
-const Hooks = function () {
-	this.initEnv = function () {
-		Function.prototype.hook = function (realFunc, hookFunc, context) {
-			let _context = null; //函数上下文
-			let _funcName = null; //函数名
-
-			_context = context || window;
-			_funcName = getFuncName(this);
-			_context["realFunc_" + _funcName] = this;
-
-			if (
-				_context[_funcName].prototype &&
-				_context[_funcName].prototype.isHooked
-			) {
-				console.log("Already has been hooked,unhook first");
-				return false;
-			}
-			function getFuncName(fn) {
-				// 获取函数名
-				let strFunc = fn.toString();
-				let _regex = /function\s+(\w+)\s*\(/;
-				let patten = strFunc.match(_regex);
-				if (patten) {
-					return patten[1];
-				}
-				return "";
-			}
-			try {
-				eval(
-					"_context[_funcName] = function " +
-						_funcName +
-						"(){\n" +
-						"let args = Array.prototype.slice.call(arguments,0);\n" +
-						"let obj = this;\n" +
-						"hookFunc.apply(obj,args);\n" +
-						"return _context['realFunc_" +
-						_funcName +
-						"'].apply(obj,args);\n" +
-						"};"
-				);
-				_context[_funcName].prototype.isHooked = true;
-				return true;
-			} catch (e) {
-				console.log("Hook failed,check the params.");
-				return false;
-			}
-		};
-		Function.prototype.unhook = function (realFunc, funcName, context) {
-			let _context = null;
-			let _funcName = null;
-			_context = context || window;
-			_funcName = funcName;
-			if (!_context[_funcName].prototype.isHooked) {
-				console.log("No function is hooked on");
-				return false;
-			}
-			_context[_funcName] = _context["realFunc" + _funcName];
-			Reflect.deleteProperty(_context, "realFunc_" + _funcName);
-			return true;
-		};
-	};
-	this.cleanEnv = function () {
-		if (Function.prototype.hasOwnProperty("hook")) {
-			Reflect.deleteProperty(unction.prototype, "hook");
-		}
-		if (Function.prototype.hasOwnProperty("unhook")) {
-			Reflect.deleteProperty(unction.prototype, "unhook");
-		}
-		return true;
-	};
-};
+class Hooks {
+    /**
+     * 在Function原型上添加自定义方法.hook和.unhook
+     */
+    initEnv() {
+        Function.prototype.hook = function (realFunc, hookFunc, context) {
+            let _context = null; //函数上下文
+            let _funcName = null; //函数名
+            _context = context || window;
+            _funcName = getFuncName(this);
+            _context["realFunc_" + _funcName] = this;
+            if (_context[_funcName].prototype &&
+                _context[_funcName].prototype.isHooked) {
+                console.log("Already has been hooked,unhook first");
+                return false;
+            }
+            function getFuncName(fn) {
+                // 获取函数名
+                let strFunc = fn.toString();
+                let _regex = /function\s+(\w+)\s*\(/;
+                let patten = strFunc.match(_regex);
+                if (patten) {
+                    return patten[1];
+                }
+                return "";
+            }
+            try {
+                eval("_context[_funcName] = function " +
+                    _funcName +
+                    "(){\n" +
+                    "let args = Array.prototype.slice.call(arguments,0);\n" +
+                    "let obj = this;\n" +
+                    "hookFunc.apply(obj,args);\n" +
+                    "return _context['realFunc_" +
+                    _funcName +
+                    "'].apply(obj,args);\n" +
+                    "};");
+                _context[_funcName].prototype.isHooked = true;
+                return true;
+            }
+            catch (e) {
+                console.log("Hook failed,check the params.");
+                return false;
+            }
+        };
+        Function.prototype.unhook = function (realFunc, funcName, context) {
+            let _context = null;
+            let _funcName = null;
+            _context = context || window;
+            _funcName = funcName;
+            if (!_context[_funcName].prototype.isHooked) {
+                console.log("No function is hooked on");
+                return false;
+            }
+            _context[_funcName] = _context["realFunc" + _funcName];
+            Reflect.deleteProperty(_context, "realFunc_" + _funcName);
+            return true;
+        };
+    }
+    /**
+     * 删除在Function原型上添加的自定义方法.hook和.unhook
+     */
+    cleanEnv() {
+        if (Function.prototype.hasOwnProperty("hook")) {
+            Reflect.deleteProperty(Function.prototype, "hook");
+        }
+        if (Function.prototype.hasOwnProperty("unhook")) {
+            Reflect.deleteProperty(Function.prototype, "unhook");
+        }
+        return true;
+    }
+}
 
-const Httpx = function (__xmlHttpRequest__) {
-	if (typeof __xmlHttpRequest__ !== "function") {
-		console.warn("Httpx未传入GM_xmlhttpRequest函数，强制默认使用fetch");
-	}
-	const GM_Api = {
-		/**
-		 * @type {GM_xmlhttpRequest}
-		 */
-		xmlHttpRequest: __xmlHttpRequest__,
-	};
-	/**
-	 * @type {HttpxDetails}
-	 */
-	let defaultDetails = {
-		url: void 0,
-		timeout: 5000,
-		async: false,
-		responseType: void 0,
-		headers: void 0,
-		data: void 0,
-		redirect: void 0,
-		cookie: 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,
-		user: void 0,
-		password: void 0,
-		onabort() {},
-		onerror() {},
-		ontimeout() {},
-		onloadstart() {},
-		onreadystatechange() {},
-		onprogress() {},
-	};
-	/**
-	 * 输出请求配置
-	 */
-	let LOG_DETAILS = false;
-
-	const HttpxRequestHook = {
-		/**
-		 * 发送请求前的回调
-		 * 如果返回false则阻止本次返回
-		 * @param {HttpxDetails} details 当前的请求配置
-		 */
-		beforeRequestCallBack(details) {},
-	};
-
-	const HttpxRequestDetails = {
-		/**
-		 * 获取请求配置
-		 * @param {HttpxMethod} method 当前请求方法，默认get
-		 * @param {(...args: any[])=>void} resolve promise回调
-		 * @param {HttpxDetails} details 请求配置
-		 * @returns
-		 */
-		getDetails(method, resolve, details) {
-			/**
-			 * @type {HttpxDetails}
-			 */
-			let result = {
-				url: details.url || defaultDetails.url,
-				method: (method || "GET").toString().toUpperCase(),
-				timeout: details.timeout || defaultDetails.timeout,
-				responseType: details.responseType || defaultDetails.responseType,
-				/* 对象使用深拷贝 */
-				headers: Utils.deepClone(defaultDetails.headers),
-				data: details.data || defaultDetails.data,
-				redirect: details.redirect || defaultDetails.redirect,
-				cookie: details.cookie || defaultDetails.cookie,
-				binary: details.binary || defaultDetails.binary,
-				nocache: details.nocache || defaultDetails.nocache,
-				revalidate: details.revalidate || defaultDetails.revalidate,
-				/* 对象使用深拷贝 */
-				context: Utils.deepClone(details.context || defaultDetails.context),
-				overrideMimeType:
-					details.overrideMimeType || defaultDetails.overrideMimeType,
-				anonymous: details.anonymous || defaultDetails.anonymous,
-				fetch: details.fetch || defaultDetails.fetch,
-				/* 对象使用深拷贝 */
-				fetchInit: Utils.deepClone(defaultDetails.fetchInit),
-				user: details.user || defaultDetails.user,
-				password: details.password || defaultDetails.password,
-				onabort(...args) {
-					HttpxCallBack.onAbort(details, resolve, args);
-				},
-				onerror(...args) {
-					HttpxCallBack.onError(details, resolve, args);
-				},
-				onloadstart(...args) {
-					HttpxCallBack.onLoadStart(details, args);
-				},
-				onprogress(...args) {
-					HttpxCallBack.onProgress(details, args);
-				},
-				onreadystatechange(...args) {
-					HttpxCallBack.onReadyStateChange(details, args);
-				},
-				ontimeout(...args) {
-					HttpxCallBack.onTimeout(details, resolve, args);
-				},
-				onload(...args) {
-					HttpxCallBack.onLoad(details, resolve, args);
-				},
-			};
-			if (typeof GM_Api.xmlHttpRequest !== "function") {
-				result.fetch = true;
-			}
-			if (typeof result.headers === "object") {
-				if (typeof details.headers === "object") {
-					Object.keys(details.headers).forEach((keyName, index) => {
-						if (keyName in result.headers && details.headers[keyName] == null) {
-							/* 在默认的header中存在，且设置它新的值为空，那么就是默认的值 */
-							Reflect.deleteProperty(result.headers, keyName);
-						} else {
-							result.headers[keyName] = details.headers[keyName];
-						}
-					});
-				}
-			} else {
-				result.headers = details.headers;
-			}
-			if (typeof result.fetchInit === "object") {
-				/* 使用assign替换且添加 */
-				if (typeof details.fetchInit === "object") {
-					Object.keys(details.fetchInit).forEach((keyName, index) => {
-						if (
-							keyName in result.fetchInit &&
-							details.fetchInit[keyName] == null
-						) {
-							/* 在默认的fetchInit中存在，且设置它新的值为空，那么就是默认的值 */
-							Reflect.deleteProperty(result.fetchInit, keyName);
-						} else {
-							result.fetchInit[keyName] = details.fetchInit[keyName];
-						}
-					});
-				}
-			} else {
-				result.fetchInit = details.fetchInit;
-			}
-			return result;
-		},
-		/**
-		 * 处理发送请求的details，去除值为undefined、空function的值
-		 * @param {HttpxDetails} details
-		 * @returns {HttpxDetails}
-		 */
-		handle(details) {
-			Object.keys(details).forEach((keyName) => {
-				if (
-					details[keyName] == null ||
-					(details[keyName] instanceof Function &&
-						Utils.isNull(details[keyName]))
-				) {
-					Reflect.deleteProperty(details, keyName);
-					return;
-				}
-			});
-			if (Utils.isNull(details.url)) {
-				throw new TypeError(`Utils.Httpx 参数 url不符合要求: ${details.url}`);
-			}
-			/* method值统一大写，兼容Via */
-			details.method = details.method.toUpperCase();
-			/* 判断是否是以http开头，否则主动加上origin */
-			try {
-				new URL(details.url);
-			} catch (error) {
-				if (details.url.startsWith("//")) {
-					details.url = globalThis.location.protocol + details.url;
-				} else if (details.url.startsWith("/")) {
-					details.url = globalThis.location.origin + details.url;
-				} else {
-					details.url = globalThis.location.origin + "/" + details.url;
-				}
-			}
-			return details;
-		},
-		/**
-		 * 处理fetch的配置
-		 * @param {HttpxDetails} details
-		 */
-		handleFetchDetail(details) {
-			/**
-			 * fetch的请求配置
-			 * @type {RequestInit}
-			 **/
-			let fetchRequestInit = {};
-			if (
-				(details.method === "GET" || details.method === "HEAD") &&
-				details.data != null
-			) {
-				/* GET 或 HEAD 方法的请求不能包含 body 信息 */
-				Reflect.deleteProperty(details, "data");
-			}
-			/* 中止信号控制器 */
-			let abortController = new AbortController();
-			let signal = abortController.signal;
-			signal.onabort = () => {
-				details.onabort({
-					isFetch: true,
-					responseText: "",
-					response: null,
-					readyState: 4,
-					responseHeaders: "",
-					status: 0,
-					statusText: "",
-					error: "aborted",
-				});
-			};
-			fetchRequestInit.method = details.method ?? "GET";
-			fetchRequestInit.headers = details.headers;
-			fetchRequestInit.body = details.data;
-			fetchRequestInit.mode = "cors";
-			fetchRequestInit.credentials = "include";
-			fetchRequestInit.cache = "no-cache";
-			fetchRequestInit.redirect = "follow";
-			fetchRequestInit.referrerPolicy = "origin-when-cross-origin";
-			fetchRequestInit.signal = signal;
-			Object.assign(fetchRequestInit, details.fetchInit || {});
-			return {
-				fetchDetails: details,
-				fetchRequestInit: fetchRequestInit,
-				abortController: abortController,
-			};
-		},
-	};
-	const HttpxCallBack = {
-		/**
-		 * onabort请求被取消-触发
-		 * @param {HttpxDetails} details 配置
-		 * @param {()=>void} resolve 回调
-		 * @param {any[]} argumentsList 参数列表
-		 */
-		onAbort(details, resolve, argumentsList) {
-			if ("onabort" in details) {
-				details.onabort.apply(this, argumentsList);
-			} else if ("onabort" in defaultDetails) {
-				defaultDetails.onabort.apply(this, argumentsList);
-			}
-			resolve({
-				status: false,
-				data: [...argumentsList],
-				msg: "请求被取消",
-				type: "onabort",
-			});
-		},
-
-		/**
-		 * onerror请求异常-触发
-		 * @param {HttpxDetails} details 配置
-		 * @param {()=>void} resolve 回调
-		 * @param {any[]} argumentsList 响应的参数列表
-		 */
-		onError(details, resolve, argumentsList) {
-			if ("onerror" in details) {
-				details.onerror.apply(this, argumentsList);
-			} else if ("onerror" in defaultDetails) {
-				defaultDetails.onerror.apply(this, argumentsList);
-			}
-			let response = argumentsList;
-			if (response.length) {
-				response = response[0];
-			}
-			resolve({
-				status: false,
-				data: response,
-				details: details,
-				msg: "请求异常",
-				type: "onerror",
-			});
-		},
-		/**
-		 * ontimeout请求超时-触发
-		 * @param {HttpxDetails} details 配置
-		 * @param {()=>void} resolve 回调
-		 * @param {any[]} argumentsList 参数列表
-		 */
-		onTimeout(details, resolve, argumentsList) {
-			if ("ontimeout" in details) {
-				details.ontimeout.apply(this, argumentsList);
-			} else if ("ontimeout" in defaultDetails) {
-				defaultDetails.ontimeout.apply(this, argumentsList);
-			}
-			resolve({
-				status: false,
-				data: [...argumentsList],
-				msg: "请求超时",
-				type: "ontimeout",
-			});
-		},
-
-		/**
-		 * onloadstart请求开始-触发
-		 * @param {HttpxDetails} details 配置
-		 * @param {any[]} argumentsList 参数列表
-		 */
-		onLoadStart(details, argumentsList) {
-			if ("onloadstart" in details) {
-				details.onloadstart.apply(this, argumentsList);
-			} else if ("onloadstart" in defaultDetails) {
-				defaultDetails.onloadstart.apply(this, argumentsList);
-			}
-		},
-		/**
-		 * onload加载完毕-触发
-		 * @param {HttpxDetails} details 请求的配置
-		 * @param {()=>void} resolve 回调
-		 * @param {...HttpxAsyncResultData[]} argumentsList 参数列表
-		 */
-		onLoad(details, resolve, argumentsList) {
-			/* X浏览器会因为设置了responseType导致不返回responseText */
-			let Response = argumentsList[0];
-			/* responseText为空，response不为空的情况 */
-			if (
-				Utils.isNull(Response["responseText"]) &&
-				Utils.isNotNull(Response["response"])
-			) {
-				if (typeof Response["response"] === "object") {
-					Utils.tryCatch().run(() => {
-						Response["responseText"] = JSON.stringify(Response["response"]);
-					});
-				} else {
-					Response["responseText"] = Response["response"];
-				}
-			}
-
-			/* response为空，responseText不为空的情况 */
-			if (
-				Response["response"] == null &&
-				typeof Response["responseText"] === "string" &&
-				Response["responseText"].trim() !== ""
-			) {
-				let newResponse = Response["responseText"];
-				if (details.responseType === "json") {
-					newResponse = Utils.toJSON(Response["responseText"]);
-				} else if (details.responseType === "document") {
-					let parser = new DOMParser();
-					newResponse = parser.parseFromString(
-						Response["responseText"],
-						"text/html"
-					);
-				} else if (details.responseType === "arraybuffer") {
-					let encoder = new TextEncoder();
-					let arrayBuffer = encoder.encode(Response["responseText"]);
-					newResponse = arrayBuffer;
-				} else if (details.responseType === "blob") {
-					let encoder = new TextEncoder();
-					let arrayBuffer = encoder.encode(Response["responseText"]);
-					newResponse = new Blob([arrayBuffer]);
-				} else {
-					newResponse = Response["responseText"];
-				}
-				try {
-					Response["response"] = newResponse;
-				} catch (error) {
-					console.warn("response 无法被覆盖");
-				}
-			}
-			/* Stay扩展中没有finalUrl，对应的是responseURL */
-			if (Response["finalUrl"] == null && Response["responseURL"] != null) {
-				Response["finalUrl"] = Response["responseURL"];
-			}
-			/* 状态码2xx都是成功的 */
-			if (Math.floor(Response.status / 100) === 2) {
-				resolve({
-					status: true,
-					data: Response,
-					details: details,
-					msg: "请求完毕",
-					type: "onload",
-				});
-			} else {
-				HttpxCallBack.onError(details, resolve, argumentsList);
-			}
-		},
-		/**
-		 * onprogress上传进度-触发
-		 * @param {HttpxDetails} details 配置
-		 * @param {any[]} argumentsList 参数列表
-		 */
-		onProgress(details, argumentsList) {
-			if ("onprogress" in details) {
-				details.onprogress.apply(this, argumentsList);
-			} else if ("onprogress" in defaultDetails) {
-				defaultDetails.onprogress.apply(this, argumentsList);
-			}
-		},
-		/**
-		 * onreadystatechange准备状态改变-触发
-		 * @param {HttpxDetails} details 配置
-		 * @param {any[]} argumentsList 参数列表
-		 */
-		onReadyStateChange(details, argumentsList) {
-			if ("onreadystatechange" in details) {
-				details.onreadystatechange.apply(this, argumentsList);
-			} else if ("onreadystatechange" in defaultDetails) {
-				defaultDetails.onreadystatechange.apply(this, argumentsList);
-			}
-		},
-	};
-
-	const HttpxRequest = {
-		/**
-		 * 发送请求
-		 * @param {HttpxDetails} details
-		 */
-		request(details) {
-			if (LOG_DETAILS) {
-				console.log("Httpx请求配置👇", details);
-			}
-			if (typeof HttpxRequestHook.beforeRequestCallBack === "function") {
-				let hookResult = HttpxRequestHook.beforeRequestCallBack(details);
-				if (typeof hookResult === "boolean" && !hookResult) {
-					return;
-				}
-			}
-			if (details.fetch) {
-				const { fetchDetails, fetchRequestInit, abortController } =
-					HttpxRequestDetails.handleFetchDetail(details);
-				this.fetch(fetchDetails, fetchRequestInit, abortController);
-			} else {
-				Reflect.deleteProperty(details, "fetchInit");
-				this.xmlHttpRequest(details);
-			}
-		},
-		/**
-		 * 使用油猴函数GM_xmlhttpRequest发送请求
-		 * @param {HttpxDetails} details
-		 */
-		xmlHttpRequest(details) {
-			GM_Api.xmlHttpRequest(details);
-		},
-		/**
-		 * 使用fetch发送请求
-		 * @param {HttpxDetails} details
-		 * @param {RequestInit} fetchRequestInit
-		 * @param {AbortController} abortController
-		 */
-		fetch(details, fetchRequestInit, abortController) {
-			fetch(details.url, fetchRequestInit)
-				.then(async (resp) => {
-					/**
-					 * @type {HttpxAsyncResultData}
-					 */
-					let httpxResponse = {
-						isFetch: true,
-						finalUrl: resp.url,
-						readyState: 4,
-						status: resp.status,
-						statusText: resp.statusText,
-						response: void 0,
-						responseFetchHeaders: resp.headers,
-						responseHeaders: "",
-						responseText: void 0,
-						responseType: details.responseType,
-						responseXML: void 0,
-					};
-					Object.assign(httpxResponse, details.context || {});
-
-					for (const [key, value] of resp.headers.entries()) {
-						httpxResponse.responseHeaders += `${key}: ${value}\n`;
-					}
-
-					/* 如果是流式传输，直接返回 */
-					if (
-						details.responseType === "stream" ||
-						(resp.headers.has("Content-Type") &&
-							resp.headers.get("Content-Type").includes("text/event-stream"))
-					) {
-						httpxResponse["isStream"] = true;
-						httpxResponse.response = resp.body;
-						Reflect.deleteProperty(httpxResponse, "responseText");
-						Reflect.deleteProperty(httpxResponse, "responseXML");
-						details.onload(httpxResponse);
-						return;
-					}
-
-					/** 响应 */
-					let response = "";
-					/** 响应字符串 */
-					let responseText = "";
-					/** 响应xml文档 */
-					let responseXML = "";
-
-					let arrayBuffer = await resp.arrayBuffer;
-
-					let encoding = "utf-8";
-					if (resp.headers.has("Content-Type")) {
-						let charsetMatched = resp.headers
-							.get("Content-Type")
-							.match(/charset=(.+)/);
-						if (charsetMatched) {
-							encoding = charsetMatched[1];
-						}
-					}
-					let textDecoder = new TextDecoder(encoding);
-					responseText = textDecoder.decode(await resp.arrayBuffer());
-					response = responseText;
-
-					if (details.responseType === "arraybuffer") {
-						response = arrayBuffer;
-					} else if (details.responseType === "blob") {
-						response = new Blob([arrayBuffer]);
-					} else if (
-						details.responseType === "document" ||
-						details.responseType == null
-					) {
-						let parser = new DOMParser();
-						response = parser.parseFromString(responseText, "text/html");
-					} else if (details.responseType === "json") {
-						response = Utils.toJSON(responseText);
-					}
-					let parser = new DOMParser();
-					responseXML = parser.parseFromString(responseText, "text/xml");
-
-					httpxResponse.response = response;
-					httpxResponse.responseText = responseText;
-					httpxResponse.responseXML = responseXML;
-
-					details.onload(httpxResponse);
-				})
-				.catch((err) => {
-					if (err.name === "AbortError") {
-						return;
-					}
-					details.onerror({
-						isFetch: true,
-						finalUrl: details.url,
-						readyState: 4,
-						status: 0,
-						statusText: "",
-						responseHeaders: "",
-						responseText: "",
-						error: err,
-					});
-				});
-			details.onloadstart({
-				isFetch: true,
-				finalUrl: details.url,
-				readyState: 1,
-				responseHeaders: "",
-				responseText: "",
-				status: 0,
-				statusText: "",
-			});
-			return {
-				abort() {
-					abortController.abort();
-				},
-			};
-		},
-	};
-
-	/**
-	 * 覆盖当前配置
-	 * @param {HttpxDetailsConfig} details
-	 */
-	this.config = function (details = {}) {
-		if ("logDetails" in details && typeof details["logDetails"] === "boolean") {
-			LOG_DETAILS = details["logDetails"];
-		}
-
-		defaultDetails = Utils.assign(defaultDetails, details);
-	};
-
-	/**
-	 * 修改xmlHttpRequest
-	 * @param {Function} httpRequest 网络请求函数
-	 */
-	this.setXMLHttpRequest = function (httpRequest) {
-		GM_Api.xmlHttpRequest = httpRequest;
-	};
-
-	/**
-	 * GET 请求
-	 * @param {...HttpxDetails|string} args
-	 * @returns {Promise< HttpxAsyncResult >}
-	 */
-	this.get = async function (...args) {
-		let details = {};
-		if (typeof args[0] === "string") {
-			details.url = args[0];
-			if (typeof args[1] === "object") {
-				details = args[1];
-				details.url = args[0];
-			}
-		} else {
-			details = args[0];
-		}
-		return new Promise((resolve) => {
-			let requestDetails = HttpxRequestDetails.getDetails(
-				"get",
-				resolve,
-				details
-			);
-			Reflect.deleteProperty(requestDetails, "onprogress");
-			requestDetails = HttpxRequestDetails.handle(requestDetails);
-			HttpxRequest.request(requestDetails);
-		});
-	};
-	/**
-	 * POST 请求
-	 * @param {...HttpxDetails|string} args
-	 * @returns {Promise< HttpxAsyncResult >}
-	 */
-	this.post = async function (...args) {
-		let details = {};
-		if (typeof args[0] === "string") {
-			details.url = args[0];
-			if (typeof args[1] === "object") {
-				details = args[1];
-				details.url = args[0];
-			}
-		} else {
-			details = args[0];
-		}
-		return new Promise((resolve) => {
-			let requestDetails = HttpxRequestDetails.getDetails(
-				"post",
-				resolve,
-				details
-			);
-			requestDetails = HttpxRequestDetails.handle(requestDetails);
-			HttpxRequest.request(requestDetails);
-		});
-	};
-	/**
-	 * HEAD 请求
-	 * @param {...HttpxDetails|string} args
-	 * @returns {Promise< HttpxAsyncResult >}
-	 */
-	this.head = async function (...args) {
-		let details = {};
-		if (typeof args[0] === "string") {
-			details.url = args[0];
-			if (typeof args[1] === "object") {
-				details = args[1];
-				details.url = args[0];
-			}
-		} else {
-			details = args[0];
-		}
-		return new Promise((resolve) => {
-			let requestDetails = HttpxRequestDetails.getDetails(
-				"head",
-				resolve,
-				details
-			);
-			Reflect.deleteProperty(requestDetails, "onprogress");
-			requestDetails = HttpxRequestDetails.handle(requestDetails);
-			HttpxRequest.request(requestDetails);
-		});
-	};
-
-	/**
-	 * OPTIONS 请求
-	 * @param {...HttpxDetails|string} args
-	 * @returns {Promise< HttpxAsyncResult >}
-	 */
-	this.options = async function (...args) {
-		let details = {};
-		if (typeof args[0] === "string") {
-			details.url = args[0];
-			if (typeof args[1] === "object") {
-				details = args[1];
-				details.url = args[0];
-			}
-		} else {
-			details = args[0];
-		}
-		return new Promise((resolve) => {
-			let requestDetails = HttpxRequestDetails.getDetails(
-				"options",
-				resolve,
-				details
-			);
-			Reflect.deleteProperty(requestDetails, "onprogress");
-			requestDetails = HttpxRequestDetails.handle(requestDetails);
-			HttpxRequest.request(requestDetails);
-		});
-	};
-
-	/**
-	 * DELETE 请求
-	 * @param {...HttpxDetails|string} args
-	 * @returns {Promise< HttpxAsyncResult >}
-	 */
-	this.delete = async function (...args) {
-		let details = {};
-		if (typeof args[0] === "string") {
-			details.url = args[0];
-			if (typeof args[1] === "object") {
-				details = args[1];
-				details.url = args[0];
-			}
-		} else {
-			details = args[0];
-		}
-		return new Promise((resolve) => {
-			let requestDetails = HttpxRequestDetails.getDetails(
-				"delete",
-				resolve,
-				details
-			);
-			Reflect.deleteProperty(requestDetails, "onprogress");
-			requestDetails = HttpxRequestDetails.handle(requestDetails);
-			HttpxRequest.request(requestDetails);
-		});
-	};
-
-	/**
-	 * PUT 请求
-	 * @param {...HttpxDetails|string} args
-	 * @returns {Promise< HttpxAsyncResult >}
-	 */
-	this.put = async function (...args) {
-		let details = {};
-		if (typeof args[0] === "string") {
-			details.url = args[0];
-			if (typeof args[1] === "object") {
-				details = args[1];
-				details.url = args[0];
-			}
-		} else {
-			details = args[0];
-		}
-		return new Promise((resolve) => {
-			let requestDetails = HttpxRequestDetails.getDetails(
-				"put",
-				resolve,
-				details
-			);
-			requestDetails = HttpxRequestDetails.handle(requestDetails);
-			HttpxRequest.request(requestDetails);
-		});
-	};
-};
+class Httpx {
+    GM_Api = {
+        xmlHttpRequest: null,
+    };
+    HttpxRequestHook = {
+        /**
+         * 发送请求前的回调
+         * 如果返回false则阻止本次返回
+         * @param details 当前的请求配置
+         */
+        beforeRequestCallBack(details) { },
+    };
+    HttpxRequestDetails = {
+        context: this,
+        /**
+         * 根据传入的参数处理获取details配置
+         */
+        handleBeforeRequestDetails(...args) {
+            let result = {};
+            if (typeof args[0] === "string") {
+                /* 传入的是url,details? */
+                let url = args[0];
+                result.url = url;
+                if (typeof args[1] === "object") {
+                    /* 处理第二个参数details */
+                    let details = args[1];
+                    result = details;
+                    result.url = url;
+                }
+            }
+            else {
+                /* 传入的是details */
+                result = args[0];
+            }
+            return result;
+        },
+        /**
+         * 获取请求配置
+         * @param method 当前请求方法，默认get
+         * @param resolve promise回调
+         * @param details 请求配置
+         */
+        getDetails(method, resolve, details) {
+            let that = this;
+            let result = {
+                url: details.url || this.context.#defaultDetails.url,
+                method: (method || "GET").toString().toUpperCase(),
+                timeout: details.timeout || this.context.#defaultDetails.timeout,
+                responseType: details.responseType || this.context.#defaultDetails.responseType,
+                /* 对象使用深拷贝 */
+                headers: utils.deepClone(this.context.#defaultDetails.headers),
+                data: details.data || this.context.#defaultDetails.data,
+                redirect: details.redirect || this.context.#defaultDetails.redirect,
+                cookie: details.cookie || this.context.#defaultDetails.cookie,
+                binary: details.binary || this.context.#defaultDetails.binary,
+                nocache: details.nocache || this.context.#defaultDetails.nocache,
+                revalidate: details.revalidate || this.context.#defaultDetails.revalidate,
+                /* 对象使用深拷贝 */
+                context: utils.deepClone(details.context || this.context.#defaultDetails.context),
+                overrideMimeType: details.overrideMimeType ||
+                    this.context.#defaultDetails.overrideMimeType,
+                anonymous: details.anonymous || this.context.#defaultDetails.anonymous,
+                fetch: details.fetch || this.context.#defaultDetails.fetch,
+                /* 对象使用深拷贝 */
+                fetchInit: utils.deepClone(this.context.#defaultDetails.fetchInit),
+                user: details.user || this.context.#defaultDetails.user,
+                password: details.password || this.context.#defaultDetails.password,
+                onabort(...args) {
+                    that.context.HttpxCallBack.onAbort(details, resolve, args);
+                },
+                onerror(...args) {
+                    that.context.HttpxCallBack.onError(details, resolve, args);
+                },
+                onloadstart(...args) {
+                    that.context.HttpxCallBack.onLoadStart(details, args);
+                },
+                onprogress(...args) {
+                    that.context.HttpxCallBack.onProgress(details, args);
+                },
+                onreadystatechange(...args) {
+                    that.context.HttpxCallBack.onReadyStateChange(details, args);
+                },
+                ontimeout(...args) {
+                    that.context.HttpxCallBack.onTimeout(details, resolve, args);
+                },
+                onload(...args) {
+                    that.context.HttpxCallBack.onLoad(details, resolve, args);
+                },
+            };
+            if (typeof this.context.GM_Api.xmlHttpRequest !== "function") {
+                result.fetch = true;
+            }
+            if (typeof result.headers === "object") {
+                if (typeof details.headers === "object") {
+                    Object.keys(details.headers).forEach((keyName, index) => {
+                        if (keyName in result.headers &&
+                            details.headers?.[keyName] == null) {
+                            /* 在默认的header中存在，且设置它新的值为空，那么就是默认的值 */
+                            Reflect.deleteProperty(result.headers, keyName);
+                        }
+                        else {
+                            result.headers[keyName] = details?.headers?.[keyName];
+                        }
+                    });
+                }
+            }
+            else {
+                result.headers = details.headers;
+            }
+            if (typeof result.fetchInit === "object") {
+                /* 使用assign替换且添加 */
+                if (typeof details.fetchInit === "object") {
+                    Object.keys(details.fetchInit).forEach((keyName, index) => {
+                        if (keyName in result.fetchInit &&
+                            details.fetchInit[keyName] == null) {
+                            /* 在默认的fetchInit中存在，且设置它新的值为空，那么就是默认的值 */
+                            Reflect.deleteProperty(result.fetchInit, keyName);
+                        }
+                        else {
+                            result.fetchInit[keyName] = details.fetchInit[keyName];
+                        }
+                    });
+                }
+            }
+            else {
+                result.fetchInit = details.fetchInit;
+            }
+            return result;
+        },
+        /**
+         * 处理发送请求的details，去除值为undefined、空function的值
+         * @param details
+         */
+        handle(details) {
+            Object.keys(details).forEach((keyName) => {
+                if (details[keyName] == null ||
+                    (details[keyName] instanceof Function &&
+                        utils.isNull(details[keyName]))) {
+                    Reflect.deleteProperty(details, keyName);
+                    return;
+                }
+            });
+            if (utils.isNull(details.url)) {
+                throw new TypeError(`Utils.Httpx 参数 url不符合要求: ${details.url}`);
+            }
+            /* method值统一大写，兼容Via */
+            details.method = details.method.toUpperCase();
+            /* 判断是否是以http开头，否则主动加上origin */
+            try {
+                new URL(details.url);
+            }
+            catch (error) {
+                if (details.url.startsWith("//")) {
+                    details.url = globalThis.location.protocol + details.url;
+                }
+                else if (details.url.startsWith("/")) {
+                    details.url = globalThis.location.origin + details.url;
+                }
+                else {
+                    details.url = globalThis.location.origin + "/" + details.url;
+                }
+            }
+            return details;
+        },
+        /**
+         * 处理fetch的配置
+         * @param details
+         */
+        handleFetchDetail(details) {
+            /**
+             * fetch的请求配置
+             **/
+            let fetchRequestInit = {};
+            if ((details.method === "GET" || details.method === "HEAD") &&
+                details.data != null) {
+                /* GET 或 HEAD 方法的请求不能包含 body 信息 */
+                Reflect.deleteProperty(details, "data");
+            }
+            /* 中止信号控制器 */
+            let abortController = new AbortController();
+            let signal = abortController.signal;
+            signal.onabort = () => {
+                details.onabort({
+                    isFetch: true,
+                    responseText: "",
+                    response: null,
+                    readyState: 4,
+                    responseHeaders: "",
+                    status: 0,
+                    statusText: "",
+                    error: "aborted",
+                });
+            };
+            fetchRequestInit.method = details.method ?? "GET";
+            fetchRequestInit.headers = details.headers;
+            fetchRequestInit.body = details.data;
+            fetchRequestInit.mode = "cors";
+            fetchRequestInit.credentials = "include";
+            fetchRequestInit.cache = "no-cache";
+            fetchRequestInit.redirect = "follow";
+            fetchRequestInit.referrerPolicy = "origin-when-cross-origin";
+            fetchRequestInit.signal = signal;
+            Object.assign(fetchRequestInit, details.fetchInit || {});
+            return {
+                fetchDetails: details,
+                fetchRequestInit: fetchRequestInit,
+                abortController: abortController,
+            };
+        },
+    };
+    HttpxCallBack = {
+        context: this,
+        /**
+         * onabort请求被取消-触发
+         * @param details 配置
+         * @param resolve 回调
+         * @param argumentsList 参数列表
+         */
+        onAbort(details, resolve, argumentsList) {
+            if ("onabort" in details) {
+                details.onabort.apply(this, argumentsList);
+            }
+            else if ("onabort" in this.context.#defaultDetails) {
+                this.context.#defaultDetails.onabort.apply(this, argumentsList);
+            }
+            resolve({
+                status: false,
+                data: [...argumentsList],
+                msg: "请求被取消",
+                type: "onabort",
+            });
+        },
+        /**
+         * onerror请求异常-触发
+         * @param details 配置
+         * @param resolve 回调
+         * @param argumentsList 响应的参数列表
+         */
+        onError(details, resolve, argumentsList) {
+            if ("onerror" in details) {
+                details.onerror.apply(this, argumentsList);
+            }
+            else if ("onerror" in this.context.#defaultDetails) {
+                this.context.#defaultDetails.onerror.apply(this, argumentsList);
+            }
+            let response = argumentsList;
+            if (response.length) {
+                response = response[0];
+            }
+            resolve({
+                status: false,
+                data: response,
+                details: details,
+                msg: "请求异常",
+                type: "onerror",
+            });
+        },
+        /**
+         * ontimeout请求超时-触发
+         * @param details 配置
+         * @param resolve 回调
+         * @param argumentsList 参数列表
+         */
+        onTimeout(details, resolve, argumentsList) {
+            if ("ontimeout" in details) {
+                details.ontimeout.apply(this, argumentsList);
+            }
+            else if ("ontimeout" in this.context.#defaultDetails) {
+                this.context.#defaultDetails.ontimeout.apply(this, argumentsList);
+            }
+            resolve({
+                status: false,
+                data: [...argumentsList],
+                msg: "请求超时",
+                type: "ontimeout",
+            });
+        },
+        /**
+         * onloadstart请求开始-触发
+         * @param details 配置
+         * @param argumentsList 参数列表
+         */
+        onLoadStart(details, argumentsList) {
+            if ("onloadstart" in details) {
+                details.onloadstart.apply(this, argumentsList);
+            }
+            else if ("onloadstart" in this.context.#defaultDetails) {
+                this.context.#defaultDetails.onloadstart.apply(this, argumentsList);
+            }
+        },
+        /**
+         * onload加载完毕-触发
+         * @param details 请求的配置
+         * @param resolve 回调
+         * @param argumentsList 参数列表
+         */
+        onLoad(details, resolve, argumentsList) {
+            /* X浏览器会因为设置了responseType导致不返回responseText */
+            let Response = argumentsList[0];
+            /* responseText为空，response不为空的情况 */
+            if (utils.isNull(Response["responseText"]) &&
+                utils.isNotNull(Response["response"])) {
+                if (typeof Response["response"] === "object") {
+                    utils.tryCatch().run(() => {
+                        Response["responseText"] = JSON.stringify(Response["response"]);
+                    });
+                }
+                else {
+                    Response["responseText"] = Response["response"];
+                }
+            }
+            /* response为空，responseText不为空的情况 */
+            if (Response["response"] == null &&
+                typeof Response["responseText"] === "string" &&
+                Response["responseText"].trim() !== "") {
+                let newResponse = Response["responseText"];
+                if (details.responseType === "json") {
+                    newResponse = utils.toJSON(Response["responseText"]);
+                }
+                else if (details.responseType === "document") {
+                    let parser = new DOMParser();
+                    newResponse = parser.parseFromString(Response["responseText"], "text/html");
+                }
+                else if (details.responseType === "arraybuffer") {
+                    let encoder = new TextEncoder();
+                    let arrayBuffer = encoder.encode(Response["responseText"]);
+                    newResponse = arrayBuffer;
+                }
+                else if (details.responseType === "blob") {
+                    let encoder = new TextEncoder();
+                    let arrayBuffer = encoder.encode(Response["responseText"]);
+                    newResponse = new Blob([arrayBuffer]);
+                }
+                else {
+                    newResponse = Response["responseText"];
+                }
+                try {
+                    Response["response"] = newResponse;
+                }
+                catch (error) {
+                    console.warn("response 无法被覆盖");
+                }
+            }
+            /* Stay扩展中没有finalUrl，对应的是responseURL */
+            if (Response["finalUrl"] == null &&
+                Response["responseURL"] != null) {
+                Response["finalUrl"] = Response["responseURL"];
+            }
+            /* 状态码2xx都是成功的 */
+            if (Math.floor(Response.status / 100) === 2) {
+                resolve({
+                    status: true,
+                    data: Response,
+                    details: details,
+                    msg: "请求完毕",
+                    type: "onload",
+                });
+            }
+            else {
+                this.context.HttpxCallBack.onError(details, resolve, argumentsList);
+            }
+        },
+        /**
+         * onprogress上传进度-触发
+         * @param details 配置
+         * @param argumentsList 参数列表
+         */
+        onProgress(details, argumentsList) {
+            if ("onprogress" in details) {
+                details.onprogress.apply(this, argumentsList);
+            }
+            else if ("onprogress" in this.context.#defaultDetails) {
+                this.context.#defaultDetails.onprogress.apply(this, argumentsList);
+            }
+        },
+        /**
+         * onreadystatechange准备状态改变-触发
+         * @param details 配置
+         * @param argumentsList 参数列表
+         */
+        onReadyStateChange(details, argumentsList) {
+            if ("onreadystatechange" in details) {
+                details.onreadystatechange.apply(this, argumentsList);
+            }
+            else if ("onreadystatechange" in this.context.#defaultDetails) {
+                this.context.#defaultDetails.onreadystatechange.apply(this, argumentsList);
+            }
+        },
+    };
+    HttpxRequest = {
+        context: this,
+        /**
+         * 发送请求
+         * @param details
+         */
+        request(details) {
+            if (this.context.#LOG_DETAILS) {
+                console.log("Httpx请求配置👇", details);
+            }
+            if (typeof this.context.HttpxRequestHook.beforeRequestCallBack ===
+                "function") {
+                let hookResult = this.context.HttpxRequestHook.beforeRequestCallBack(details);
+                if (typeof hookResult === "boolean" && !hookResult) {
+                    return;
+                }
+            }
+            if (details.fetch) {
+                const { fetchDetails, fetchRequestInit, abortController } = this.context.HttpxRequestDetails.handleFetchDetail(details);
+                this.fetch(fetchDetails, fetchRequestInit, abortController);
+            }
+            else {
+                Reflect.deleteProperty(details, "fetchInit");
+                this.xmlHttpRequest(details);
+            }
+        },
+        /**
+         * 使用油猴函数GM_xmlhttpRequest发送请求
+         * @param details
+         */
+        xmlHttpRequest(details) {
+            this.context.GM_Api.xmlHttpRequest(details);
+        },
+        /**
+         * 使用fetch发送请求
+         * @param details
+         * @param fetchRequestInit
+         * @param abortController
+         */
+        fetch(details, fetchRequestInit, abortController) {
+            fetch(details.url, fetchRequestInit)
+                .then(async (resp) => {
+                /**
+                 * @type {HttpxAsyncResultData}
+                 */
+                let httpxResponse = {
+                    isFetch: true,
+                    finalUrl: resp.url,
+                    readyState: 4,
+                    status: resp.status,
+                    statusText: resp.statusText,
+                    response: void 0,
+                    responseFetchHeaders: resp.headers,
+                    responseHeaders: "",
+                    responseText: void 0,
+                    responseType: details.responseType,
+                    responseXML: void 0,
+                };
+                Object.assign(httpxResponse, details.context || {});
+                for (const [key, value] of resp.headers.entries()) {
+                    httpxResponse.responseHeaders += `${key}: ${value}\n`;
+                }
+                /* 如果是流式传输，直接返回 */
+                if (details.responseType === "stream" ||
+                    (resp.headers.has("Content-Type") &&
+                        resp.headers.get("Content-Type").includes("text/event-stream"))) {
+                    httpxResponse["isStream"] = true;
+                    httpxResponse.response = resp.body;
+                    Reflect.deleteProperty(httpxResponse, "responseText");
+                    Reflect.deleteProperty(httpxResponse, "responseXML");
+                    details.onload(httpxResponse);
+                    return;
+                }
+                /** 响应 */
+                let response = "";
+                /** 响应字符串 */
+                let responseText = "";
+                /** 响应xml文档 */
+                let responseXML = "";
+                let arrayBuffer = await resp.arrayBuffer;
+                let encoding = "utf-8";
+                if (resp.headers.has("Content-Type")) {
+                    let charsetMatched = resp.headers
+                        .get("Content-Type")
+                        ?.match(/charset=(.+)/);
+                    if (charsetMatched) {
+                        encoding = charsetMatched[1];
+                    }
+                }
+                let textDecoder = new TextDecoder(encoding);
+                responseText = textDecoder.decode(await resp.arrayBuffer());
+                response = responseText;
+                if (details.responseType === "arraybuffer") {
+                    response = arrayBuffer;
+                }
+                else if (details.responseType === "blob") {
+                    response = new Blob([arrayBuffer]);
+                }
+                else if (details.responseType === "document" ||
+                    details.responseType == null) {
+                    let parser = new DOMParser();
+                    response = parser.parseFromString(responseText, "text/html");
+                }
+                else if (details.responseType === "json") {
+                    response = utils.toJSON(responseText);
+                }
+                let parser = new DOMParser();
+                responseXML = parser.parseFromString(responseText, "text/xml");
+                httpxResponse.response = response;
+                httpxResponse.responseText = responseText;
+                httpxResponse.responseXML = responseXML;
+                details.onload(httpxResponse);
+            })
+                .catch((err) => {
+                if (err.name === "AbortError") {
+                    return;
+                }
+                details.onerror({
+                    isFetch: true,
+                    finalUrl: details.url,
+                    readyState: 4,
+                    status: 0,
+                    statusText: "",
+                    responseHeaders: "",
+                    responseText: "",
+                    error: err,
+                });
+            });
+            details.onloadstart({
+                isFetch: true,
+                finalUrl: details.url,
+                readyState: 1,
+                responseHeaders: "",
+                responseText: "",
+                status: 0,
+                statusText: "",
+            });
+            return {
+                abort() {
+                    abortController.abort();
+                },
+            };
+        },
+    };
+    /**
+     * 默认配置
+     */
+    #defaultDetails = {
+        url: void 0,
+        timeout: 5000,
+        async: false,
+        responseType: void 0,
+        headers: void 0,
+        data: void 0,
+        redirect: void 0,
+        cookie: 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,
+        user: void 0,
+        password: void 0,
+        onabort() { },
+        onerror() { },
+        ontimeout() { },
+        onloadstart() { },
+        onreadystatechange() { },
+        onprogress() { },
+    };
+    /**
+     * 当前使用请求时，输出请求的配置
+     */
+    #LOG_DETAILS = false;
+    constructor(__xmlHttpRequest__) {
+        if (typeof __xmlHttpRequest__ !== "function") {
+            console.warn("Httpx未传入GM_xmlhttpRequest函数或传入的GM_xmlhttpRequest不是Function，强制使用window.fetch");
+        }
+        this.GM_Api.xmlHttpRequest = __xmlHttpRequest__;
+    }
+    /**
+     * 覆盖当前配置
+     * @param details
+     */
+    config(details = {}) {
+        if ("logDetails" in details && typeof details["logDetails"] === "boolean") {
+            this.#LOG_DETAILS = details["logDetails"];
+        }
+        this.#defaultDetails = utils.assign(this.#defaultDetails, details);
+    }
+    /**
+     * 修改xmlHttpRequest
+     * @param httpRequest 网络请求函数
+     */
+    setXMLHttpRequest(httpRequest) {
+        this.GM_Api.xmlHttpRequest = httpRequest;
+    }
+    /**
+     * GET 请求
+     */
+    async get(...args) {
+        let that = this;
+        let details = this.HttpxRequestDetails.handleBeforeRequestDetails(...args);
+        return new Promise((resolve) => {
+            let requestDetails = that.HttpxRequestDetails.getDetails("get", resolve, details);
+            Reflect.deleteProperty(requestDetails, "onprogress");
+            requestDetails = that.HttpxRequestDetails.handle(requestDetails);
+            that.HttpxRequest.request(requestDetails);
+        });
+    }
+    /**
+     * POST 请求
+     */
+    async post(...args) {
+        let that = this;
+        let details = this.HttpxRequestDetails.handleBeforeRequestDetails(...args);
+        return new Promise((resolve) => {
+            let requestDetails = that.HttpxRequestDetails.getDetails("post", resolve, details);
+            requestDetails = that.HttpxRequestDetails.handle(requestDetails);
+            that.HttpxRequest.request(requestDetails);
+        });
+    }
+    /**
+     * HEAD 请求
+     */
+    async head(...args) {
+        let that = this;
+        let details = this.HttpxRequestDetails.handleBeforeRequestDetails(...args);
+        return new Promise((resolve) => {
+            let requestDetails = that.HttpxRequestDetails.getDetails("head", resolve, details);
+            Reflect.deleteProperty(requestDetails, "onprogress");
+            requestDetails = that.HttpxRequestDetails.handle(requestDetails);
+            that.HttpxRequest.request(requestDetails);
+        });
+    }
+    /**
+     * OPTIONS 请求
+     */
+    async options(...args) {
+        let that = this;
+        let details = this.HttpxRequestDetails.handleBeforeRequestDetails(...args);
+        return new Promise((resolve) => {
+            let requestDetails = that.HttpxRequestDetails.getDetails("options", resolve, details);
+            Reflect.deleteProperty(requestDetails, "onprogress");
+            requestDetails = that.HttpxRequestDetails.handle(requestDetails);
+            that.HttpxRequest.request(requestDetails);
+        });
+    }
+    /**
+     * DELETE 请求
+     */
+    async delete(...args) {
+        let that = this;
+        let details = this.HttpxRequestDetails.handleBeforeRequestDetails(...args);
+        return new Promise((resolve) => {
+            let requestDetails = that.HttpxRequestDetails.getDetails("delete", resolve, details);
+            Reflect.deleteProperty(requestDetails, "onprogress");
+            requestDetails = that.HttpxRequestDetails.handle(requestDetails);
+            that.HttpxRequest.request(requestDetails);
+        });
+    }
+    /**
+     * PUT 请求
+     */
+    async put(...args) {
+        let that = this;
+        let details = this.HttpxRequestDetails.handleBeforeRequestDetails(...args);
+        return new Promise((resolve) => {
+            let requestDetails = that.HttpxRequestDetails.getDetails("put", resolve, details);
+            requestDetails = that.HttpxRequestDetails.handle(requestDetails);
+            that.HttpxRequest.request(requestDetails);
+        });
+    }
+}
 
-const indexedDB = function (
-	dbName = "default_db",
-	storeName = "default_form",
-	dbVersion = 1
-) {
-	this.dbName = dbName;
-	/* websql的版本号，由于ios的问题，版本号的写法不一样 */
-	this.slqVersion = "1";
-	this.dbVersion = dbVersion;
-	this.storeName = storeName;
-	/* 监听IndexDB */
-	this.indexedDB =
-		window.indexedDB ||
-		window.mozIndexedDB ||
-		window.webkitIndexedDB ||
-		window.msIndexedDB;
-	if (!this.indexedDB) {
-		alert("很抱歉，您的浏览器不支持indexedDB");
-	}
-	/* 缓存数据库，避免同一个页面重复创建和销毁 */
-	this.db = {};
-	this.store = null;
-	this.errorCode = {
-		/* 错误码 */
-		success: {
-			code: 200,
-			msg: "操作成功",
-		},
-		error: {
-			code: 401,
-			msg: "操作失败",
-		},
-		open: { code: 91001, msg: "打开数据库失败" },
-		save: { code: 91002, msg: "保存数据失败" },
-		get: { code: 91003, msg: "获取数据失败" },
-		delete: { code: 91004, msg: "删除数据失败" },
-		deleteAll: { code: 91005, msg: "清空数据库失败" },
-	};
-	let that = this;
-	/**
-	 * 创建 “表”
-	 * @param {string} dbName 表名
-	 * @returns
-	 */
-	this.createStore = function (dbName) {
-		let txn, store;
-		if (that.indexedDB) {
-			/* 如果是支持IndexDB的 */
-			txn = that.db[dbName].transaction(that.storeName, "readwrite");
-			/* IndexDB的读写权限 */
-			store = txn.objectStore(that.storeName);
-		}
-		return store;
-	};
-	/**
-	 * 打开数据库
-	 * @param {function} callback  回调
-	 * @param {string} dbName 数据库名
-	 */
-	this.open = function (callback, dbName) {
-		/* 打开数据库 */
-		if (that.indexedDB) {
-			/* 如果支持IndexDB */
-			if (!that.db[dbName]) {
-				/* 如果缓存中没有，则进行数据库的创建或打开，提高效率 */
-				let request = that.indexedDB.open(dbName, that.dbVersion);
-				request.onerror = function (e) {
-					callback({
-						code: that.errorCode.open.code,
-						msg: that.errorCode.open.msg,
-						error: e,
-					});
-				};
-				request.onsuccess = function (e) {
-					if (!that.db[dbName]) {
-						that.db[dbName] = e.target.result;
-					}
-					let store = that.createStore(dbName);
-					callback(store);
-				};
-				request.onupgradeneeded = function (e) {
-					that.db[dbName] = e.target.result;
-					let store = that.db[dbName].createObjectStore(that.storeName, {
-						keyPath: "key",
-					});
-					store.transaction.oncomplete = function (event) {
-						callback(store);
-					};
-				};
-			} else {
-				/* 如果缓存中已经打开了数据库，就直接使用 */
-				let store = that.createStore(dbName);
-				callback(store);
-			}
-		}
-	};
-	/**
-	 * 保存数据到数据库
-	 * @param {string} key 数据key
-	 * @param {any} value 数据值
-	 * @returns {Promise< {
-	 *    code: number,
-	 *    msg: string,
-	 *    success: boolean
-	 * }>}
-	 */
-	this.save = async function (key, value) {
-		if (that.indexedDB) {
-			return new Promise((resolve, reject) => {
-				let dbName = that.dbName;
-				let inData = {
-					key: key,
-					value: value,
-				};
-				that.open(function (result) {
-					let error = result.hasOwnProperty("error");
-					if (error) {
-						resolve(result);
-					} else {
-						let request = result.put(inData);
-						request.onsuccess = function (e) {
-							/* 保存成功有success 字段 */
-							resolve({
-								code: that.errorCode.success.code,
-								msg: that.errorCode.success.msg,
-								success: true,
-							});
-						};
-						request.onerror = function (e) {
-							resolve({
-								code: that.errorCode.save.code,
-								msg: that.errorCode.save.msg,
-								error: e,
-							});
-						};
-					}
-				}, dbName);
-			});
-		}
-	};
-	/**
-	 * 根据key获取值
-	 * @param {string} key 数据key
-	 * @returns {Promise< {
-	 *    code: number,
-	 *    msg: string,
-	 *    data: [...any],
-	 *    success: true
-	 * }| {
-	 *    code: number,
-	 *    msg: string,
-	 *    error: Error,
-	 *    result: any,
-	 * } >}
-	 */
-	this.get = async function (key) {
-		return new Promise((resolve, reject) => {
-			let dbName = that.dbName;
-			if (that.indexedDB) {
-				that.open(function (result) {
-					/* 判断返回的数据中是否有error字段 */
-					let error = result.hasOwnProperty("error");
-					if (error) {
-						reject({
-							code: that.errorCode.open.get,
-							msg: that.errorCode.get.msg,
-							error: error,
-							result: result,
-						});
-					} else {
-						let request = result.get(key);
-						request.onsuccess = function (e) {
-							let result = e.target.result;
-							let data = result ? result.value : void 0;
-							resolve({
-								code: data
-									? that.errorCode.success.code
-									: that.errorCode.error.code,
-								msg: data
-									? that.errorCode.success.msg
-									: that.errorCode.error.msg,
-								data: data || [],
-								success: true,
-							});
-						};
-						request.onerror = function (e) {
-							reject({
-								code: that.errorCode.get.code,
-								msg: that.errorCode.get.msg,
-								result: result,
-								error: e,
-							});
-						};
-					}
-				}, dbName);
-			}
-		});
-	};
-	/**
-	 * 正则获取数据
-	 * @param {string} key 数据键
-	 * @returns { Promise<{
-	 *    code: number,
-	 *    msg: string,
-	 *    data: [...any],
-	 *    success: true
-	 * }|{
-	 *    code: number,
-	 *    msg: string,
-	 *    error: Error,
-	 *    result: any,
-	 * }> }
-	 */
-	this.regexpGet = async function (key) {
-		let list = [];
-		return new Promise((resolve, reject) => {
-			/* 正则查询 */
-			let dbName = that.dbName;
-			if (that.indexedDB) {
-				that.open(function (result) {
-					/* 判断返回的数据中是否有error字段 */
-					let error = result.hasOwnProperty("error");
-					if (error) {
-						reject({
-							code: that.errorCode.open.get,
-							msg: that.errorCode.get.msg,
-							error: error,
-							result: result,
-						});
-					} else {
-						let request = result.getAll();
-						request.onsuccess = function (e) {
-							let result = e.target.result;
-							if (result.length !== 0) {
-								result.forEach((item, index) => {
-									if (item["key"].match(key)) {
-										let concatList = item["value"];
-										concatList["key"] = item["key"];
-										list = [...list, concatList];
-									}
-								});
-							}
-							resolve({
-								code: that.errorCode.success.code,
-								msg: that.errorCode.success.msg,
-								data: list,
-								success: true,
-							});
-						};
-						request.onerror = function (e) {
-							reject({
-								code: that.errorCode.get.code,
-								msg: that.errorCode.get.msg,
-								result: result,
-								error: e,
-							});
-						};
-					}
-				}, dbName);
-			}
-		});
-	};
-	/**
-	 * 删除数据
-	 * @param {string} key 数据键
-	 * @returns {Promise<{
-	 *    code: number,
-	 *    msg: string,
-	 *    success: true,
-	 * }|{
-	 *    code: number,
-	 *    msg: string,
-	 *    error: Error,
-	 * }>}
-	 */
-	this.delete = async function (key) {
-		return new Promise((resolve, reject) => {
-			/* 根据key删除某条数据 */
-			let dbName = that.dbName;
-			if (that.indexedDB) {
-				that.open(function (result) {
-					let error = result.hasOwnProperty("error");
-					if (error) {
-						resolve(result);
-					} else {
-						let request = result.get(key);
-						request.onsuccess = function (e) {
-							let recode = e.target.result;
-							if (recode) {
-								request = result.delete(key);
-							}
-							resolve({
-								code: recode
-									? that.errorCode.success.code
-									: that.errorCode.error.code,
-								msg: recode
-									? that.errorCode.success.msg
-									: that.errorCode.error.msg,
-								success: true,
-							});
-						};
-						request.onerror = function (e) {
-							resolve({
-								code: that.errorCode.delete.code,
-								msg: that.errorCode.delete.msg,
-								error: e,
-							});
-						};
-					}
-				}, dbName);
-			}
-		});
-	};
-	/**
-	 * 删除所有数据
-	 * @returns {Promise<{
-	 *    code: number,
-	 *    msg: string,
-	 *    error: Error,
-	 *    result: any,
-	 * }|{
-	 *    code: number,
-	 *    msg: string,
-	 *    success: true,
-	 * }>}
-	 */
-	this.deleteAll = async function () {
-		return new Promise((resolve, reject) => {
-			/* 清空数据库 */
-			let dbName = that.dbName;
-			if (that.indexedDB) {
-				that.open(function (result) {
-					let error = result.hasOwnProperty("error");
-					if (error) {
-						resolve({
-							code: that.errorCode.deleteAll.code,
-							msg: that.errorCode.deleteAll.msg,
-							error: error,
-							result: result,
-						});
-					} else {
-						result.clear();
-						resolve({
-							code: that.errorCode.success.code,
-							msg: that.errorCode.success.msg,
-							success: true,
-						});
-					}
-				}, dbName);
-			}
-		});
-	};
-};
+class indexedDB {
+    #dbName;
+    #storeName;
+    #dbVersion;
+    /* websql的版本号，由于ios的问题，版本号的写法不一样 */
+    #slqVersion = "1";
+    /* 监听IndexDB */
+    #indexedDB = window.indexedDB ||
+        window.mozIndexedDB ||
+        window.webkitIndexedDB ||
+        window.msIndexedDB;
+    /* 缓存数据库，避免同一个页面重复创建和销毁 */
+    #db = {};
+    #store = null;
+    #errorCode = {
+        /* 错误码 */
+        success: {
+            code: 200,
+            msg: "操作成功",
+        },
+        error: {
+            code: 401,
+            msg: "操作失败",
+        },
+        open: { code: 91001, msg: "打开数据库失败" },
+        save: { code: 91002, msg: "保存数据失败" },
+        get: { code: 91003, msg: "获取数据失败" },
+        delete: { code: 91004, msg: "删除数据失败" },
+        deleteAll: { code: 91005, msg: "清空数据库失败" },
+        regexpGet: { code: 91006, msg: "正则获取数据失败" },
+    };
+    /**
+     * @param dbName 数据存储名，默认为：default_db
+     * @param storeName 表名，默认为：default_form
+     * @param dbVersion indexDB的版本号，默认为：1
+     */
+    constructor(dbName = "default_db", storeName = "default_form", dbVersion = 1) {
+        this.#dbName = dbName;
+        this.#storeName = storeName;
+        this.#dbVersion = dbVersion;
+        if (!this.#indexedDB) {
+            alert("很抱歉，您的浏览器不支持indexedDB");
+            throw new TypeError("很抱歉，您的浏览器不支持indexedDB");
+        }
+    }
+    /**
+     * 创建 “表”
+     * @param dbName 表名
+     */
+    createStore(dbName) {
+        let txn, store;
+        txn = this.#db[dbName].transaction(this.#storeName, "readwrite");
+        /* IndexDB的读写权限 */
+        store = txn.objectStore(this.#storeName);
+        this.#store = store;
+        return store;
+    }
+    /**
+     * 打开数据库
+     * @param callback  回调
+     * @param dbName 数据库名
+     */
+    open(callback, dbName) {
+        let that = this;
+        /* 打开数据库 */
+        /* 如果支持IndexDB */
+        if (!that.#db[dbName]) {
+            /* 如果缓存中没有，则进行数据库的创建或打开，提高效率 */
+            let request = that.#indexedDB.open(dbName, that.#dbVersion);
+            request.onerror = function (event) {
+                callback({
+                    code: that.#errorCode.open.code,
+                    msg: that.#errorCode.open.msg,
+                    event: event,
+                }, false);
+            };
+            request.onsuccess = function (event) {
+                if (!that.#db[dbName]) {
+                    let target = event.target;
+                    that.#db[dbName] = target.result;
+                }
+                let store = that.createStore(dbName);
+                callback(store, true);
+            };
+            request.onupgradeneeded = function (event) {
+                let target = event.target;
+                that.#db[dbName] = target.result;
+                let store = that.#db[dbName].createObjectStore(that.#storeName, {
+                    keyPath: "key",
+                });
+                store.transaction.oncomplete = function (event) {
+                    callback(store, true);
+                };
+            };
+        }
+        else {
+            /* 如果缓存中已经打开了数据库，就直接使用 */
+            let store = that.createStore(dbName);
+            callback(store, true);
+        }
+    }
+    /**
+     * 保存数据到数据库
+     * @param key 数据key
+     * @param value 数据值
+     */
+    async save(key, value) {
+        let that = this;
+        return new Promise((resolve) => {
+            let dbName = that.#dbName;
+            let inData = {
+                key: key,
+                value: value,
+            };
+            that.open(function (idbStore, success) {
+                if (!success) {
+                    resolve({
+                        success: false,
+                        code: that.#errorCode.save.code,
+                        msg: that.#errorCode.save.msg,
+                    });
+                }
+                else {
+                    idbStore = idbStore;
+                    let request = idbStore.put(inData);
+                    request.onsuccess = function (event) {
+                        /* 保存成功有success 字段 */
+                        event.target;
+                        resolve({
+                            success: true,
+                            code: that.#errorCode.success.code,
+                            msg: that.#errorCode.success.msg,
+                            event: event,
+                        });
+                    };
+                    request.onerror = function (event) {
+                        event.target;
+                        resolve({
+                            success: false,
+                            code: that.#errorCode.save.code,
+                            msg: that.#errorCode.save.msg,
+                            event: event,
+                        });
+                    };
+                }
+            }, dbName);
+        });
+    }
+    /**
+     * 根据key获取值
+     * @param key 数据key
+     */
+    async get(key) {
+        let that = this;
+        return new Promise((resolve) => {
+            let dbName = that.#dbName;
+            that.open(function (idbStore, success) {
+                /* 判断返回的数据中是否有error字段 */
+                if (!success) {
+                    resolve({
+                        success: false,
+                        code: that.#errorCode.get.code,
+                        msg: that.#errorCode.get.msg,
+                        data: void 0,
+                    });
+                }
+                else {
+                    idbStore = idbStore;
+                    let request = idbStore.get(key);
+                    request.onsuccess = function (event) {
+                        let target = event.target;
+                        let result = target.result;
+                        /* result 返回的是 {key: string, value: any} */
+                        /* 键值对存储 */
+                        let data = result ? result.value : void 0;
+                        if (data) {
+                            resolve({
+                                success: true,
+                                code: that.#errorCode.success.code,
+                                msg: that.#errorCode.success.msg,
+                                data: data,
+                                event: event,
+                                result: result,
+                            });
+                        }
+                        else {
+                            resolve({
+                                success: false,
+                                code: that.#errorCode.error.code,
+                                msg: that.#errorCode.error.msg,
+                                data: void 0,
+                                event: event,
+                                result: result,
+                            });
+                        }
+                    };
+                    request.onerror = function (event) {
+                        event.target;
+                        resolve({
+                            success: false,
+                            code: that.#errorCode.get.code,
+                            msg: that.#errorCode.get.msg,
+                            data: void 0,
+                            event: event,
+                        });
+                    };
+                }
+            }, dbName);
+        });
+    }
+    /**
+     * 正则获取数据
+     * @param key 数据键
+     */
+    async regexpGet(key) {
+        let list = [];
+        let that = this;
+        return new Promise((resolve) => {
+            /* 正则查询 */
+            let dbName = that.#dbName;
+            that.open(function (idbStore, success) {
+                /* 判断返回的数据中是否有error字段 */
+                if (!success) {
+                    resolve({
+                        success: false,
+                        code: that.#errorCode.regexpGet.code,
+                        msg: that.#errorCode.regexpGet.msg,
+                        data: [],
+                    });
+                }
+                else {
+                    idbStore = idbStore;
+                    let request = idbStore.getAll();
+                    request.onsuccess = function (event) {
+                        let target = event.target;
+                        let result = target.result;
+                        if (result.length !== 0) {
+                            result.forEach((item, index) => {
+                                if (item["key"].match(key)) {
+                                    let concatList = item["value"];
+                                    concatList["key"] = item["key"];
+                                    list = [...list, concatList];
+                                }
+                            });
+                        }
+                        resolve({
+                            success: true,
+                            code: that.#errorCode.success.code,
+                            msg: that.#errorCode.success.msg,
+                            data: list,
+                            event: event,
+                        });
+                    };
+                    request.onerror = function (event) {
+                        event.target;
+                        resolve({
+                            success: false,
+                            code: that.#errorCode.get.code,
+                            msg: that.#errorCode.get.msg,
+                            data: [],
+                            event: event,
+                        });
+                    };
+                }
+            }, dbName);
+        });
+    }
+    /**
+     * 删除数据
+     * @param {string} key 数据键
+     */
+    async delete(key) {
+        let that = this;
+        return new Promise((resolve) => {
+            /* 根据key删除某条数据 */
+            let dbName = that.#dbName;
+            that.open(function (idbStore, success) {
+                if (!success) {
+                    resolve({
+                        success: false,
+                        code: that.#errorCode.delete.code,
+                        msg: that.#errorCode.delete.msg,
+                    });
+                }
+                else {
+                    idbStore = idbStore;
+                    let request = idbStore.get(key);
+                    request.onsuccess = function (event) {
+                        let target = event.target;
+                        let recode = target.result;
+                        if (recode) {
+                            /* 成功 */
+                            request = idbStore.delete(key);
+                            resolve({
+                                success: true,
+                                code: that.#errorCode.success.code,
+                                msg: that.#errorCode.success.msg,
+                            });
+                        }
+                        else {
+                            resolve({
+                                success: false,
+                                code: that.#errorCode.error.code,
+                                msg: that.#errorCode.error.msg,
+                            });
+                        }
+                    };
+                    request.onerror = function (event) {
+                        event.target;
+                        resolve({
+                            success: false,
+                            code: that.#errorCode.delete.code,
+                            msg: that.#errorCode.delete.msg,
+                            event: event,
+                        });
+                    };
+                }
+            }, dbName);
+        });
+    }
+    /**
+     * 删除所有数据
+     */
+    async deleteAll() {
+        let that = this;
+        return new Promise((resolve) => {
+            /* 清空数据库 */
+            let dbName = that.#dbName;
+            that.open(function (idbStore, success) {
+                if (!success) {
+                    resolve({
+                        success: false,
+                        code: that.#errorCode.deleteAll.code,
+                        msg: that.#errorCode.deleteAll.msg,
+                    });
+                }
+                else {
+                    idbStore = idbStore;
+                    idbStore.clear();
+                    resolve({
+                        success: true,
+                        code: that.#errorCode.success.code,
+                        msg: that.#errorCode.success.msg,
+                    });
+                }
+            }, dbName);
+        });
+    }
+}
 
-const LockFunction = function (callback, context, delayTime = 0) {
-	let flag = false;
-	let that = this;
-	context = context || this;
-	/**
-	 * 锁
-	 */
-	this.lock = function () {
-		flag = true;
-	};
-	/**
-	 * 解锁
-	 */
-	this.unlock = function () {
-		setTimeout(() => {
-			flag = false;
-		}, delayTime);
-	};
-	/**
-	 * 执行
-	 */
-	this.run = async function (...args) {
-		if (flag) {
-			return;
-		}
-		that.lock();
-		await callback.apply(context, args);
-		that.unlock();
-	};
-};
+class LockFunction {
+    #flag = false;
+    #delayTime = 0;
+    #callback;
+    #context;
+    constructor(callback, context, delayTime) {
+        this.#callback = callback;
+        if (typeof context === "number") {
+            this.#delayTime = context;
+            this.#context = utils;
+        }
+        else {
+            this.#delayTime = delayTime;
+            this.#context = context;
+        }
+    }
+    /**
+     * 判断是否被锁
+     */
+    isLock() {
+        return this.#flag;
+    }
+    /**
+     * 锁
+     */
+    lock() {
+        this.#flag = true;
+    }
+    /**
+     * 解锁
+     */
+    unlock() {
+        setTimeout(() => {
+            this.#flag = false;
+        }, this.#delayTime);
+    }
+    /**
+     * 执行
+     */
+    async run(...args) {
+        if (this.isLock()) {
+            return;
+        }
+        this.lock();
+        await this.#callback.apply(this.#context, args);
+        this.unlock();
+    }
+}
 
-const Log = function (
-	_GM_info_ = {
-		script: {
-			name: "Utils.Log",
-		},
-	},
-	console = globalThis.console
-) {
-	let msgColorDetails = [
-		"font-weight: bold; color: cornflowerblue",
-		"font-weight: bold; color: cornflowerblue",
-		"font-weight: bold; color: darkorange",
-		"font-weight: bold; color: cornflowerblue",
-	];
-	/**
-	 * @type {UtilsLogOptions}
-	 */
-	let details = {
-		tag: true,
-		successColor: "#0000FF",
-		errorColor: "#FF0000",
-		infoColor: "0",
-		warnColor: "0",
-		debug: false,
-		autoClearConsole: false,
-		logMaxCount: 999,
-	};
-	let logCount = 0;
-	/**
-	 * 解析Error的堆栈获取实际调用者的函数名及函数所在的位置
-	 * @param {string[]} stack
-	 * @returns {{
-	 *   name: string,
-	 *   position: string,
-	 * }}
-	 */
-	let parseErrorStack = function (stack) {
-		let result = {
-			name: "",
-			position: "",
-		};
-		for (let stackString of stack) {
-			stackString = stackString.trim();
-			let stackFunctionName = stackString.match(/^at[\s]+(.+?)[\s]+/i);
-			let stackFunctionNamePosition = stackString.match(
-				/^at[\s]+.+[\s]+\((.+?)\)/i
-			);
-			if (stackFunctionName == null) {
-				continue;
-			}
-			stackFunctionName = stackFunctionName[stackFunctionName.length - 1];
-			stackFunctionNamePosition =
-				stackFunctionNamePosition[stackFunctionNamePosition.length - 1];
-			if (
-				stackFunctionName === "" ||
-				stackFunctionName.match(
-					new RegExp(
-						"(^Utils.Log.|.<anonymous>$|^Function.each|^NodeList.forEach|^k.fn.init.each)",
-						"g"
-					)
-				)
-			) {
-				continue;
-			} else {
-				result.name = stackFunctionName;
-				result.position = stackFunctionNamePosition;
-				break;
-			}
-		}
-		if (result.position === "") {
-			let lastStackString = stack[stack.length - 1].trim();
-			if (lastStackString.startsWith("at chrome-extension://")) {
-				let lastStackMatch = lastStackString.match(/^at[\s]+(.+)/);
-				if (lastStackMatch) {
-					result.position = lastStackMatch[lastStackMatch.length - 1];
-				}
-			}
-		}
-		if (result.position === "") {
-			result.position = stack[stack.length - 1].trim().replace(/^at[\s]*/g, "");
-		}
-		return result;
-	};
-	/**
-	 * 待恢复的函数或对象
-	 */
-	let recoveryList = [];
-	/**
-	 * 检测清理控制台
-	 * @this {Utils.Log}
-	 */
-	let checkClearConsole = function () {
-		logCount++;
-		if (details.autoClearConsole && logCount > details.logMaxCount) {
-			console.clear();
-			logCount = 0;
-		}
-	};
-	/**
-	 * 输出内容
-	 * @param {any} msg 需要输出的内容
-	 * @param {string} color 颜色
-	 * @param {string|undefined} otherStyle 其它CSS
-	 * @this {Utils.Log}
-	 */
-	let printContent = function (msg, color, otherStyle) {
-		checkClearConsole.apply(this);
-		otherStyle = otherStyle || "";
-		let stackSplit = new Error().stack.split("\n");
-		stackSplit.splice(0, 2);
-		let { name: callerName, position: callerPosition } =
-			parseErrorStack(stackSplit);
-		let tagName = this.tag;
-		function consoleMsg(_msg_) {
-			if (typeof _msg_ === "string") {
-				console.log(
-					`%c[${tagName}%c-%c${callerName}%c]%c %s`,
-					...msgColorDetails,
-					`color: ${color};${otherStyle}`,
-					_msg_
-				);
-			} else if (typeof _msg_ === "number") {
-				console.log(
-					`%c[${tagName}%c-%c${callerName}%c]%c %d`,
-					...msgColorDetails,
-					`color: ${color};${otherStyle}`,
-					_msg_
-				);
-			} else if (typeof _msg_ === "object") {
-				console.log(
-					`%c[${tagName}%c-%c${callerName}%c]%c %o`,
-					...msgColorDetails,
-					`color: ${color};${otherStyle}`,
-					_msg_
-				);
-			} else {
-				console.log(_msg_);
-			}
-		}
-		if (Array.isArray(msg)) {
-			msg.forEach((item) => {
-				consoleMsg(item);
-			});
-		} else {
-			consoleMsg(msg);
-		}
-		if (details.debug) {
-			/* 如果开启调试模式，输出堆栈位置 */
-			console.log(callerPosition);
-		}
-	};
-	/**
-	 * 前面的TAG标志
-	 */
-	this.tag = _GM_info_?.script?.name || "Utils.Log";
-	/**
-	 * 控制台-普通输出
-	 * @param {any} msg 需要输出的内容，如果想输出多个，修改成数组，且数组内的长度最大值为4个
-	 * @param {string|undefined} color 输出的颜色
-	 * @param {string|undefined} otherStyle 其它CSS
-	 */
-	this.info = function (msg, color = details.infoColor, otherStyle) {
-		printContent.call(this, msg, color, otherStyle);
-	};
-	/**
-	 * 控制台-警告输出
-	 * @param {any} msg 需要输出的内容，如果想输出多个，修改成数组，且数组内的长度最大值为4个
-	 * @param {string|undefined} color 输出的颜色
-	 * @param {string|undefined} otherStyle 其它CSS
-	 */
-	this.warn = function (
-		msg,
-		color = details.warnColor,
-		otherStyle = "background: #FEF6D5;padding: 4px 6px 4px 0px;"
-	) {
-		printContent.call(this, msg, color, otherStyle);
-	};
-	/**
-	 * 控制台-错误输出
-	 * @param {any} msg 需要输出的内容，如果想输出多个，修改成数组，且数组内的长度最大值为4个
-	 * @param {string|undefined} color 输出的颜色
-	 * @param {string|undefined} otherStyle 其它CSS
-	 */
-	this.error = function (msg, color = details.errorColor, otherStyle) {
-		printContent.call(this, msg, color, otherStyle);
-	};
-	/**
-	 * 控制台-成功输出
-	 * @param {any} msg 需要输出的内容，如果想输出多个，修改成数组，且数组内的长度最大值为4个
-	 * @param {string|undefined} color 输出的颜色
-	 * @param {string|undefined} otherStyle 其它CSS
-	 */
-	this.success = function (msg, color = details.successColor, otherStyle) {
-		printContent.call(this, msg, color, otherStyle);
-	};
-	/**
-	 * 控制台-输出表格
-	 * @param {object[]} msg
-	 * @param {string|undefined} color 输出的颜色
-	 * @param {string|undefined} otherStyle 其它CSS
-	 * @example
-	 * log.table([{"名字":"example","值":"123"},{"名字":"example2","值":"345"}])
-	 */
-	this.table = function (msg, color = details.infoColor, otherStyle = "") {
-		checkClearConsole.apply(this);
-		let stack = new Error().stack.split("\n");
-		stack.splice(0, 1);
-		let errorStackParse = parseErrorStack(stack);
-		let stackFunctionName = errorStackParse.name;
-		let stackFunctionNamePosition = errorStackParse.position;
-		let callerName = stackFunctionName;
-		console.log(
-			`%c[${this.tag}%c-%c${callerName}%c]%c`,
-			...msgColorDetails,
-			`color: ${color};${otherStyle}`
-		);
-		console.table(msg);
-		if (details.debug) {
-			console.log(stackFunctionNamePosition);
-		}
-	};
-	/**
-	 * 配置Log对象的颜色
-	 * @param {UtilsLogOptions} paramDetails 配置信息
-	 */
-	this.config = function (paramDetails) {
-		details = Object.assign(details, paramDetails);
-	};
-	/**
-	 * 禁用输出
-	 */
-	this.disable = function () {
-		let that = this;
-		Object.keys(this)
-			.filter((keyName) => Boolean(keyName.match(/info|error|success|table/)))
-			.forEach((keyName) => {
-				let value = {};
-				value[keyName] = that[keyName];
-				recoveryList = [...recoveryList, value];
-				that[keyName] = () => {};
-			});
-	};
-	/**
-	 * 恢复输出
-	 */
-	this.recovery = function () {
-		let that = this;
-		recoveryList.forEach((item) => {
-			let keyName = Object.keys(item);
-			that[keyName] = item[keyName];
-		});
-		recoveryList = [];
-	};
-};
+class Log {
+    /** 前面的TAG标志 */
+    #disable = false;
+    tag = "";
+    #console = null;
+    #logCount = 0;
+    #details = {
+        tag: true,
+        successColor: "#0000FF",
+        errorColor: "#FF0000",
+        infoColor: "0",
+        warnColor: "0",
+        debug: false,
+        autoClearConsole: false,
+        logMaxCount: 999,
+    };
+    /**
+     * 待恢复的函数或对象
+     */
+    #recoveryList = [];
+    #msgColorDetails = [
+        "font-weight: bold; color: cornflowerblue",
+        "font-weight: bold; color: cornflowerblue",
+        "font-weight: bold; color: darkorange",
+        "font-weight: bold; color: cornflowerblue",
+    ];
+    /**
+     * @param _GM_info_ 油猴管理器的API GM_info，或者是一个对象，如{"script":{name:"Utils.Log"}}
+     * @param console 可指定console对象为unsafeWindow下的console或者是油猴window下的console
+     */
+    constructor(_GM_info_ = {
+        script: {
+            name: "Utils.Log",
+        },
+    }, console = global.console) {
+        this.tag = _GM_info_.script.name;
+        this.#console = console;
+    }
+    /**
+     * 解析Error的堆栈获取实际调用者的函数名及函数所在的位置
+     * @param stack
+     */
+    parseErrorStack(stack) {
+        let result = {
+            name: "",
+            position: "",
+        };
+        for (let stackString of stack) {
+            stackString = stackString.trim();
+            let stackFunctionNameMatch = stackString.match(/^at[\s]+(.+?)[\s]+/i);
+            let stackFunctionNamePositionMatch = stackString.match(/^at[\s]+.+[\s]+\((.+?)\)/i);
+            if (stackFunctionNameMatch == null) {
+                continue;
+            }
+            if (stackFunctionNamePositionMatch == null) {
+                continue;
+            }
+            let stackFunctionName = stackFunctionNameMatch[stackFunctionNameMatch.length - 1];
+            let stackFunctionNamePosition = stackFunctionNamePositionMatch[stackFunctionNamePositionMatch.length - 1];
+            if (stackFunctionName === "" ||
+                stackFunctionName.match(new RegExp("(^Utils.Log.|.<anonymous>$|^Function.each|^NodeList.forEach|^k.fn.init.each)", "g"))) {
+                continue;
+            }
+            else {
+                result.name = stackFunctionName;
+                result.position = stackFunctionNamePosition;
+                break;
+            }
+        }
+        if (result.position === "") {
+            let lastStackString = stack[stack.length - 1].trim();
+            if (lastStackString.startsWith("at chrome-extension://")) {
+                let lastStackMatch = lastStackString.match(/^at[\s]+(.+)/);
+                if (lastStackMatch) {
+                    result.position = lastStackMatch[lastStackMatch.length - 1];
+                }
+            }
+        }
+        if (result.position === "") {
+            result.position = stack[stack.length - 1].trim().replace(/^at[\s]*/g, "");
+        }
+        return result;
+    }
+    /**
+     * 检测清理控制台
+     */
+    checkClearConsole() {
+        this.#logCount++;
+        if (this.#details.autoClearConsole &&
+            this.#logCount > this.#details.logMaxCount) {
+            this.#console.clear();
+            this.#logCount = 0;
+        }
+    }
+    /**
+     * 输出内容
+     * @param msg 需要输出的内容
+     * @param color 颜色
+     * @param otherStyle 其它CSS
+     */
+    printContent(msg, color, otherStyle) {
+        this.checkClearConsole.apply(this);
+        otherStyle = otherStyle || "";
+        let stackSplit = new Error().stack.split("\n");
+        stackSplit.splice(0, 2);
+        let { name: callerName, position: callerPosition } = this.parseErrorStack(stackSplit);
+        let tagName = this.tag;
+        let that = this;
+        function consoleMsg(_msg_) {
+            if (typeof _msg_ === "string") {
+                that.#console.log(`%c[${tagName}%c-%c${callerName}%c]%c %s`, ...that.#msgColorDetails, `color: ${color};${otherStyle}`, _msg_);
+            }
+            else if (typeof _msg_ === "number") {
+                that.#console.log(`%c[${tagName}%c-%c${callerName}%c]%c %d`, ...that.#msgColorDetails, `color: ${color};${otherStyle}`, _msg_);
+            }
+            else if (typeof _msg_ === "object") {
+                that.#console.log(`%c[${tagName}%c-%c${callerName}%c]%c %o`, ...that.#msgColorDetails, `color: ${color};${otherStyle}`, _msg_);
+            }
+            else {
+                that.#console.log(_msg_);
+            }
+        }
+        if (Array.isArray(msg)) {
+            msg.forEach((item) => {
+                consoleMsg(item);
+            });
+        }
+        else {
+            consoleMsg(msg);
+        }
+        if (this.#details.debug) {
+            /* 如果开启调试模式，输出堆栈位置 */
+            this.#console.log(callerPosition);
+        }
+    }
+    /**
+     * 控制台-普通输出
+     * @param msg 需要输出的内容，如果想输出多个，修改成数组，且数组内的长度最大值为4个
+     * @param color 输出的颜色
+     * @param otherStyle 其它CSS
+     */
+    info(msg, color = this.#details.infoColor, otherStyle) {
+        if (this.#disable)
+            return;
+        this.printContent.call(this, msg, color, otherStyle);
+    }
+    /**
+     * 控制台-警告输出
+     * @param msg 需要输出的内容，如果想输出多个，修改成数组，且数组内的长度最大值为4个
+     * @param color 输出的颜色
+     * @param otherStyle 其它CSS
+     */
+    warn(msg, color = this.#details.warnColor, otherStyle = "background: #FEF6D5;padding: 4px 6px 4px 0px;") {
+        if (this.#disable)
+            return;
+        this.printContent.call(this, msg, color, otherStyle);
+    }
+    /**
+     * 控制台-错误输出
+     * @param msg 需要输出的内容，如果想输出多个，修改成数组，且数组内的长度最大值为4个
+     * @param color 输出的颜色
+     * @param otherStyle 其它CSS
+     */
+    error(msg, color = this.#details.errorColor, otherStyle) {
+        if (this.#disable)
+            return;
+        this.printContent.call(this, msg, color, otherStyle);
+    }
+    /**
+     * 控制台-成功输出
+     * @param msg 需要输出的内容，如果想输出多个，修改成数组，且数组内的长度最大值为4个
+     * @param color 输出的颜色
+     * @param otherStyle 其它CSS
+     */
+    success(msg, color = this.#details.successColor, otherStyle) {
+        if (this.#disable)
+            return;
+        this.printContent.call(this, msg, color, otherStyle);
+    }
+    /**
+     * 控制台-输出表格
+     * @param msg
+     * @param color 输出的颜色
+     * @param otherStyle 其它CSS
+     * @example
+     * log.table([{"名字":"example","值":"123"},{"名字":"example2","值":"345"}])
+     */
+    table(msg, color = this.#details.infoColor, otherStyle = "") {
+        if (this.#disable)
+            return;
+        this.checkClearConsole.apply(this);
+        let stack = new Error().stack.split("\n");
+        stack.splice(0, 1);
+        let errorStackParse = this.parseErrorStack(stack);
+        let stackFunctionName = errorStackParse.name;
+        let stackFunctionNamePosition = errorStackParse.position;
+        let callerName = stackFunctionName;
+        this.#console.log(`%c[${this.tag}%c-%c${callerName}%c]%c`, ...this.#msgColorDetails, `color: ${color};${otherStyle}`);
+        this.#console.table(msg);
+        if (this.#details.debug) {
+            this.#console.log(stackFunctionNamePosition);
+        }
+    }
+    /**
+     * 配置Log对象的颜色
+     * @param paramDetails 配置信息
+     */
+    config(paramDetails) {
+        this.#details = Object.assign(this.#details, paramDetails);
+    }
+    /** 禁用输出 */
+    disable() {
+        this.#disable = true;
+    }
+    /** 恢复输出 */
+    recovery() {
+        this.#disable = false;
+    }
+}
 
-const Progress = function (paramConfig) {
-	this.config = {
-		/**
-		 * canvas元素节点
-		 * @type {HTMLCanvasElement}
-		 */
-		canvasNode: null,
-		/**
-		 * 绘制角度
-		 */
-		deg: 95,
-		/**
-		 * 进度
-		 */
-		progress: 0,
-		/**
-		 * 绘制的线宽度
-		 */
-		lineWidth: 10,
-		/**
-		 * 绘制的背景颜色
-		 */
-		lineBgColor: "#1e637c",
-		/**
-		 * 绘制的线的颜色
-		 */
-		lineColor: "#25deff",
-		/**
-		 * 绘制的字体颜色
-		 */
-		textColor: "#000000",
-		/**
-		 * 绘制的字体大小(px)
-		 */
-		fontSize: 22,
-		/**
-		 * 绘制的圆的半径
-		 */
-		circleRadius: 50,
-		/**
-		 * 控制绘制的函数
-		 */
-		draw: () => {},
-	};
-	this.config = Utils.assign(this.config, paramConfig);
-	if (!(this.config.canvasNode instanceof HTMLCanvasElement)) {
-		throw new Error("Utils.Progress 参数 canvasNode 必须是 HTMLCanvasElement");
-	}
-	/* 获取画笔 */
-	let ctx = this.config.canvasNode.getContext("2d");
-	/* 元素宽度 */
-	let width = this.config.canvasNode.width;
-	/* 元素高度 */
-	let height = this.config.canvasNode.height;
-
-	/* 清除锯齿 */
-	if (window.devicePixelRatio) {
-		this.config.canvasNode.style.width = width + "px";
-		this.config.canvasNode.style.height = height + "px";
-		this.config.canvasNode.height = height * window.devicePixelRatio;
-		this.config.canvasNode.width = width * window.devicePixelRatio;
-		ctx.scale(window.devicePixelRatio, window.devicePixelRatio);
-	}
-	/* 设置线宽 */
-	ctx.lineWidth = this.config.lineWidth;
-	/* 绘制 */
-	this.draw = function () {
-		let degActive = (this.config.progress * 360) / 100;
-		/* 清除画布 */
-		ctx.clearRect(0, 0, width, height);
-		/* 开始绘制底圆 */
-		ctx.beginPath();
-		ctx.arc(width / 2, height / 2, this.config.circleRadius, 1, 8);
-		ctx.strokeStyle = this.config.lineBgColor;
-		ctx.stroke();
-		/* 开始绘制动态圆 */
-		ctx.beginPath();
-		ctx.arc(
-			width / 2,
-			height / 2,
-			this.config.circleRadius,
-			-Math.PI / 2,
-			(degActive * Math.PI) / 180 - Math.PI / 2
-		);
-		ctx.strokeStyle = this.config.lineColor;
-		ctx.stroke();
-		/* 获取百分比 */
-		let txt = parseInt(this.config.progress) + "%";
-		ctx.font = this.config.fontSize + "px SimHei";
-		/* 获取文本宽度 */
-		let w = ctx.measureText(txt).width;
-		let h = this.config.fontSize / 2;
-		ctx.fillStyle = this.config.textColor;
-		ctx.fillText(txt, width / 2 - w / 2, height / 2 + h / 2);
-	}.bind(this);
-};
+class Progress {
+    #config = {
+        /**
+         * canvas元素节点
+         */
+        canvasNode: null,
+        /**
+         * 绘制角度
+         */
+        deg: 95,
+        /**
+         * 进度
+         */
+        progress: 0,
+        /**
+         * 绘制的线宽度
+         */
+        lineWidth: 10,
+        /**
+         * 绘制的背景颜色
+         */
+        lineBgColor: "#1e637c",
+        /**
+         * 绘制的线的颜色
+         */
+        lineColor: "#25deff",
+        /**
+         * 绘制的字体颜色
+         */
+        textColor: "#000000",
+        /**
+         * 绘制的字体大小(px)
+         */
+        fontSize: 22,
+        /**
+         * 绘制的圆的半径
+         */
+        circleRadius: 50,
+    };
+    #ctx = null;
+    #width = null;
+    #height = null;
+    /**
+     *
+     * @param paramConfig 配置信息
+     */
+    constructor(paramConfig) {
+        this.#config = utils.assign(this.#config, paramConfig);
+        if (!(this.#config.canvasNode instanceof HTMLCanvasElement)) {
+            throw new Error("Utils.Progress 参数 canvasNode 必须是 HTMLCanvasElement");
+        }
+        this.init();
+    }
+    /**
+     * 初始化
+     */
+    init() {
+        /* 获取画笔 */
+        let ctx = this.#config.canvasNode.getContext("2d");
+        if (ctx == null) {
+            throw new Error("Utils.Progress 获取画笔失败");
+        }
+        this.#ctx = ctx;
+        /* 元素宽度 */
+        this.#width = this.#config.canvasNode.width;
+        /* 元素高度 */
+        this.#height = this.#config.canvasNode.height;
+        /* 清除锯齿 */
+        if (window.devicePixelRatio) {
+            this.#config.canvasNode.style.width = this.#width + "px";
+            this.#config.canvasNode.style.height = this.#height + "px";
+            this.#config.canvasNode.height = this.#height * window.devicePixelRatio;
+            this.#config.canvasNode.width = this.#width * window.devicePixelRatio;
+            this.#ctx.scale(window.devicePixelRatio, window.devicePixelRatio);
+        }
+        /* 设置线宽 */
+        this.#ctx.lineWidth = this.#config.lineWidth;
+    }
+    /**
+     * 绘制
+     */
+    draw() {
+        let degActive = (this.#config.progress * 360) / 100;
+        /* 清除画布 */
+        this.#ctx.clearRect(0, 0, this.#width, this.#height);
+        /* 开始绘制底圆 */
+        this.#ctx.beginPath();
+        this.#ctx.arc(this.#width / 2, this.#height / 2, this.#config.circleRadius, 1, 8);
+        this.#ctx.strokeStyle = this.#config.lineBgColor;
+        this.#ctx.stroke();
+        /* 开始绘制动态圆 */
+        this.#ctx.beginPath();
+        this.#ctx.arc(this.#width / 2, this.#height / 2, this.#config.circleRadius, -Math.PI / 2, (degActive * Math.PI) / 180 - Math.PI / 2);
+        this.#ctx.strokeStyle = this.#config.lineColor;
+        this.#ctx.stroke();
+        /* 获取百分比 */
+        let txt = parseInt(this.#config.progress.toString()) + "%";
+        this.#ctx.font = this.#config.fontSize + "px SimHei";
+        /* 获取文本宽度 */
+        let w = this.#ctx.measureText(txt).width;
+        let h = this.#config.fontSize / 2;
+        this.#ctx.fillStyle = this.#config.textColor;
+        this.#ctx.fillText(txt, this.#width / 2 - w / 2, this.#height / 2 + h / 2);
+    }
+}
 
-/**
- * 
- * @param  {...any} args 
- * @returns 
- */
-const TryCatch = function (...args) {
-	/* 定义变量和函数 */
-	let callbackFunction = null;
-	let context = null;
-	let handleError = null;
-	let defaultDetails = {
-		log: true,
-	};
-	/**
-	 * @function tryCatchObj
-	 * @description 空函数，用于链式调用。
-	 */
-	function tryCatchObj() {}
-
-	/**
-	 * 配置
-	 * @param {{
-	 * log: boolean
-	 * }} paramDetails
-	 */
-	tryCatchObj.config = function (paramDetails) {
-		defaultDetails = Utils.assign(defaultDetails, paramDetails);
-		return tryCatchObj;
-	};
-	/**
-	 * 设置错误处理函数。
-	 * @param {function|string} handler 错误处理函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
-	 * @returns 返回 tryCatchObj 函数。
-	 */
-	tryCatchObj.error = function (handler) {
-		handleError = handler;
-		return tryCatchObj;
-	};
-
-	/**
-	 * 执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
-	 * @param {function|string} callback 待执行函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
-	 * @param {object|null} [__context__] 待执行函数的作用域，用于apply指定
-	 * @returns 如果函数有返回值，则返回该返回值；否则返回 tryCatchObj 函数以支持链式调用。
-	 * @throws {Error} 如果传入参数不符合要求，则会抛出相应类型的错误。
-	 */
-	tryCatchObj.run = function (callback, __context__) {
-		callbackFunction = callback;
-		context = __context__;
-		let result = executeTryCatch(callbackFunction, handleError, context);
-		return result !== void 0 ? result : tryCatchObj;
-	};
-
-	/**
-	 * 执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
-	 * @param {function|string} callback - 待执行函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
-	 * @param {function|string|null} handleErrorFunc - 错误处理函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
-	 * @param {object|null} funcThis - 待执行函数的作用域，用于apply指定
-	 * @returns {any|undefined} - 如果函数有返回值，则返回该返回值；否则返回 undefined。
-	 */
-	function executeTryCatch(callback, handleErrorFunc, funcThis) {
-		let result = void 0;
-		try {
-			if (typeof callback === "string") {
-				(function () {
-					eval(callback);
-				}).apply(funcThis, args);
-			} else {
-				result = callback.apply(funcThis, args);
-			}
-		} catch (error) {
-			if (defaultDetails.log) {
-				console.log(
-					`%c ${callback?.name ? callback?.name : callback + "出现错误"} `,
-					"color: #f20000"
-				);
-				console.log(`%c 错误原因：${error}`, "color: #f20000");
-				console.trace(callback);
-			}
-			if (handleErrorFunc) {
-				if (typeof handleErrorFunc === "string") {
-					result = function () {
-						return eval(handleErrorFunc);
-					}.apply(funcThis, [...args, error]);
-				} else {
-					result = handleErrorFunc.apply(funcThis, [...args, error]);
-				}
-			}
-		}
-		return result;
-	}
-
-	// 返回 tryCatchObj 函数
-	return tryCatchObj;
+const TryCatch = function (...args) {
+    /* 定义变量和函数 */
+    let callbackFunction = null;
+    let context = null;
+    let handleError = (error) => { };
+    let defaultDetails = {
+        log: true,
+    };
+    const TryCatchCore = {
+        /**
+         *
+         * @param paramDetails 配置
+         * @returns
+         */
+        config(paramDetails) {
+            defaultDetails = utils.assign(defaultDetails, paramDetails);
+            return TryCatchCore;
+        },
+        /**
+         * 处理错误
+         * @param handler
+         */
+        error(handler) {
+            // @ts-ignore
+            handleError = handler;
+            return TryCatchCore;
+        },
+        /**
+         * 执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
+         * @param callback 待执行函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+         * @param __context__ 待执行函数的作用域，用于apply指定
+         * @returns 如果函数有返回值，则返回该返回值；否则返回 tryCatchObj 函数以支持链式调用。
+         * @throws {Error} 如果传入参数不符合要求，则会抛出相应类型的错误。
+         */
+        run(callback, __context__) {
+            callbackFunction = callback;
+            context = __context__ || this;
+            let result = executeTryCatch(callbackFunction, handleError, context);
+            // @ts-ignore
+            return result !== void 0 ? result : TryCatchCore;
+        },
+    };
+    /**
+     * 执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
+     * @param callback - 待执行函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+     * @param handleErrorFunc - 错误处理函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+     * @param funcThis - 待执行函数的作用域，用于apply指定
+     * @returns 如果函数有返回值，则返回该返回值；否则返回 undefined。
+     */
+    function executeTryCatch(callback, handleErrorFunc, funcThis) {
+        let result = void 0;
+        try {
+            if (typeof callback === "string") {
+                (function () {
+                    eval(callback);
+                }).apply(funcThis, args);
+            }
+            else {
+                result = callback.apply(funcThis, args);
+            }
+        }
+        catch (error) {
+            if (defaultDetails.log) {
+                callback = callback;
+                console.log(`%c ${callback?.name ? callback?.name : callback + "出现错误"} `, "color: #f20000");
+                console.log(`%c 错误原因：${error}`, "color: #f20000");
+                console.trace(callback);
+            }
+            if (handleErrorFunc) {
+                if (typeof handleErrorFunc === "string") {
+                    result = function () {
+                        return eval(handleErrorFunc);
+                        // @ts-ignore
+                    }.apply(funcThis, [...args, error]);
+                }
+                else {
+                    result = handleErrorFunc.apply(funcThis, [...args, error]);
+                }
+            }
+        }
+        return result;
+    }
+    return TryCatchCore;
 };
 
-class UtilsDictionary {
-	items = {};
-	/**
-	 * 检查是否有某一个键
-	 * @param {string} key 键
-	 * @returns {boolean}
-	 */
-	has(key) {
-		return this.items.hasOwnProperty(key);
-	}
-	/**
-	 * 检查已有的键中是否以xx开头
-	 * @param {string} key 需要匹配的键
-	 * @returns {boolean}
-	 */
-	startsWith(key) {
-		let allKeys = this.keys();
-		for (const keyName of allKeys) {
-			if (keyName.startsWith(key)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	/**
-	 * 获取以xx开头的键的值
-	 * @param {string} key 需要匹配的键
-	 * @returns {any}
-	 */
-	getStartsWith(key) {
-		let allKeys = this.keys();
-		for (const keyName of allKeys) {
-			if (keyName.startsWith(key)) {
-				return this.items[keyName];
-			}
-		}
-	}
-	/**
-	 * 为字典添加某一个值
-	 * @param {string} key 键
-	 * @param {any} val 值，默认为""
-	 */
-	set(key, val = "") {
-		if (key === void 0) {
-			throw new Error("Utils.Dictionary().set 参数 key 不能为空");
-		}
-		this.items[key] = val;
-	}
-	/**
-	 * 删除某一个键
-	 * @param {string} key 键
-	 * @returns {boolean}
-	 */
-	delete(key) {
-		if (this.has(key)) {
-			Reflect.deleteProperty(this.items, key);
-			return true;
-		}
-		return false;
-	}
-	/**
-	 * 获取某个键的值
-	 * @param {string} key 键
-	 * @returns {any}
-	 */
-	get(key) {
-		return this.has(key) ? this.items[key] : void 0;
-	}
-	/**
-	 * 返回字典中的所有值
-	 * @returns {any[]}
-	 */
-	values() {
-		let resultList = [];
-		for (let prop in this.items) {
-			if (this.has(prop)) {
-				resultList.push(this.items[prop]);
-			}
-		}
-		return resultList;
-	}
-	/**
-	 * 清空字典
-	 */
-	clear() {
-		this.items = null;
-		this.items = {};
-	}
-	/**
-	 * 获取字典的长度
-	 * @returns {number}
-	 */
-	size() {
-		return Object.keys(this.items).length;
-	}
-	/**
-	 * 获取字典所有的键
-	 */
-	keys() {
-		return Object.keys(this.items);
-	}
-	/**
-	 * 返回字典本身
-	 * @returns {object}
-	 */
-	getItems() {
-		return this.items;
-	}
-	/**
-	 * 合并另一个字典
-	 * @param {object} data 需要合并的字典
-	 */
-	concat(data) {
-		this.items = Utils.assign(this.items, data.getItems());
-	}
-	forEach(callbackfn) {
-		for (const key in this.items) {
-			callbackfn(this.get(key), key, this.items);
-		}
-	}
-	/**
-	 * 获取字典的长度，同this.size
-	 * @returns {number}
-	 */
-	get length() {
-		return this.size();
-	}
-	/**
-	 * 迭代器
-	 */
-	get entries() {
-		let that = this;
-		return function* () {
-			let itemKeys = Object.keys(that.getItems());
-			for (const keyName of itemKeys) {
-				yield [keyName, that.get(keyName)];
-			}
-		};
-	}
-	/**
-	 * 是否可遍历
-	 */
-	get [Symbol.iterator]() {
-		let that = this;
-		return function () {
-			return that.entries();
-		};
-	}
-	/**
-	 * .toString()和.toLocaleString()输出的字符串
-	 */
-	get [Symbol.toStringTag]() {
-		return "UtilsDictionary";
-	}
+class UtilsDictionary {
+    #items = {};
+    constructor() { }
+    /**
+     * 检查是否有某一个键
+     * @param key 键
+     */
+    has(key) {
+        return this.#items.hasOwnProperty(key);
+    }
+    /**
+     * 检查已有的键中是否以xx开头
+     * @param key 需要匹配的键
+     */
+    startsWith(key) {
+        let allKeys = this.keys();
+        for (const keyName of allKeys) {
+            if (keyName.startsWith(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 获取以xx开头的键的值
+     * @param key 需要匹配的键
+     */
+    getStartsWith(key) {
+        let allKeys = this.keys();
+        let result = null;
+        for (const keyName of allKeys) {
+            if (keyName.startsWith(key)) {
+                result = this.#items[keyName];
+                break;
+            }
+        }
+        return result;
+    }
+    /**
+     * 为字典添加某一个值
+     * @param key 键
+     * @param val 值，默认为""
+     */
+    set(key, val) {
+        if (key === void 0) {
+            throw new Error("Utils.Dictionary().set 参数 key 不能为空");
+        }
+        this.#items[key] = val;
+    }
+    /**
+     * 删除某一个键
+     * @param key 键
+     */
+    delete(key) {
+        if (this.has(key)) {
+            Reflect.deleteProperty(this.#items, key);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 获取某个键的值
+     * @param key 键
+     */
+    get(key) {
+        return this.has(key) ? this.getItems()[key] : void 0;
+    }
+    /**
+     * 返回字典中的所有值
+     */
+    values() {
+        let resultList = [];
+        for (let prop in this.getItems()) {
+            if (this.has(prop)) {
+                resultList.push(this.getItems()[prop]);
+            }
+        }
+        return resultList;
+    }
+    /**
+     * 清空字典
+     */
+    clear() {
+        this.#items = void 0;
+        this.#items = {};
+    }
+    /**
+     * 获取字典的长度
+     */
+    size() {
+        return Object.keys(this.getItems()).length;
+    }
+    /**
+     * 获取字典所有的键
+     */
+    keys() {
+        return Object.keys(this.getItems());
+    }
+    /**
+     * 返回字典本身
+     */
+    getItems() {
+        return this.#items;
+    }
+    /**
+     * 合并另一个字典
+     * @param data 需要合并的字典
+     */
+    concat(data) {
+        this.#items = utils.assign(this.#items, data.getItems());
+    }
+    forEach(callbackfn) {
+        for (const key in this.getItems()) {
+            callbackfn(this.get(key), key, this.getItems());
+        }
+    }
+    /**
+     * 获取字典的长度，同this.size
+     */
+    get length() {
+        return this.size();
+    }
+    /**
+     * 迭代器
+     */
+    get entries() {
+        let that = this;
+        return function* () {
+            let itemKeys = Object.keys(that.getItems());
+            for (const keyName of itemKeys) {
+                yield [keyName, that.get(keyName)];
+            }
+        };
+    }
+    /**
+     * 是否可遍历
+     */
+    get [Symbol.iterator]() {
+        let that = this;
+        return function () {
+            return that.entries();
+        };
+    }
 }
 
 /// <reference path="./ajaxHooker/index.d.ts" />
-/// <reference path="./Dictionary/index.d.ts" />
-/// <reference path="./Hooks/index.d.ts" />
-/// <reference path="./Httpx/index.d.ts" />
-/// <reference path="./indexedDB/index.d.ts" />
-/// <reference path="./LockFunction/index.d.ts" />
-/// <reference path="./Log/index.d.ts" />
-/// <reference path="./Progress/index.d.ts" />
-/// <reference path="./tryCatch/index.d.ts" />
-/// <reference path="./UtilsGMMenu/index.d.ts" />
-let Utils$1 = class Utils {
+class Utils {
     /** 版本号 */
     version = "2024.5.25";
     addStyle(cssText) {
@@ -5631,7 +5486,6 @@ let Utils$1 = class Utils {
     }
     /**
      * 提供一个封装了 try-catch 的函数，可以执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
-     * @returns 返回一个对象，其中包含 error 和 run 两个方法。
      * @example
      * Utils.tryCatch().error().run(()=>{console.log(1)});
      * > 1
@@ -6037,8 +5891,8 @@ let Utils$1 = class Utils {
             });
         }
     }
-};
-let utils = new Utils$1();
+}
+let utils = new Utils();
 
 export { utils as default };
 //# sourceMappingURL=index.esm.js.map