@whitesev/utils 1.0.5 → 1.0.8

package/dist/index.system.js

@@ -945,2284 +945,2139 @@ System.register('Utils', [], (function (exports) {
             	})();
             };
 
-            /**
-             * 
-             * @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: null,
+                    /**
+                     * 设置数据到存储
+                     */
+                    setValue: null,
+                    /**
+                     * 注册菜单
+                     */
+                    registerMenuCommand: null,
+                    /**
+                     * 卸载菜单
+                     */
+                    unregisterMenuCommand: null,
+                };
+                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) {
@@ -5636,7 +5491,6 @@ System.register('Utils', [], (function (exports) {
                 }
                 /**
                  * 提供一个封装了 try-catch 的函数，可以执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
-                 * @returns 返回一个对象，其中包含 error 和 run 两个方法。
                  * @example
                  * Utils.tryCatch().error().run(()=>{console.log(1)});
                  * > 1
@@ -6042,8 +5896,8 @@ System.register('Utils', [], (function (exports) {
                         });
                     }
                 }
-            };
-            let utils = exports("default", new Utils$1());
+            }
+            let utils = exports("default", new Utils());
 
         })
     };