@whitesev/utils 1.0.0

package/src/Utils.ts

@@ -0,0 +1,4495 @@
+import { ColorConversion } from "./ColorConversion";
+import { UtilsDictionary } from "./Dictionary";
+import { GBKEncoder } from "./GBKEncoder";
+import { UtilsCore } from "./UtilsCore";
+import { UtilsGMCookie } from "./UtilsGMCookie";
+import { ajaxHooker } from "./ajaxHooker";
+import { GMMenu } from "./UtilsGMMenu";
+import { Hooks } from "./Hooks";
+import { Httpx } from "./Httpx";
+import { indexedDB } from "./indexedDB";
+import { LockFunction } from "./LockFunction";
+import { Log } from "./Log";
+import { Progress } from "./Progress";
+import { TryCatch } from "./tryCatch";
+
+class Utils {
+	/** 版本号 */
+	version = "2024.5.24";
+
+	/**
+	 * 在页面中增加style元素，如果html节点存在子节点，添加子节点第一个，反之，添加到html节点的子节点最后一个
+	 * @param cssText css字符串
+	 * @returns 返回添加的CSS标签
+	 * @example
+	 * Utils.GM_addStyle("html{}");
+	 * > <style type="text/css">html{}</style>
+	 */
+	addStyle(cssText: string): HTMLStyleElement;
+	addStyle(cssText: string) {
+		if (typeof cssText !== "string") {
+			throw new Error("Utils.addStyle 参数cssText 必须为String类型");
+		}
+		let cssNode = document.createElement("style");
+		cssNode.setAttribute("type", "text/css");
+		cssNode.innerHTML = cssText;
+		if (document.head) {
+			/* 插入head最后 */
+			document.head.appendChild(cssNode);
+		} else if (document.body) {
+			/* 插入body后 */
+			document.body.appendChild(cssNode);
+		} else if (document.documentElement.childNodes.length === 0) {
+			/* 插入#html第一个元素后 */
+			document.documentElement.appendChild(cssNode);
+		} else {
+			/* 插入head前面 */
+			document.documentElement.insertBefore(
+				cssNode,
+				document.documentElement.childNodes[0]
+			);
+		}
+		return cssNode;
+	}
+
+	/** 
+     * JSON数据从源端替换到目标端中，如果目标端存在该数据则替换，不添加，返回结果为目标端替换完毕的结果
+     * @param target 目标数据
+     * @param source 源数据
+     * @param isAdd 是否可以追加键，默认false
+     * @example
+     * Utils.assign({"1":1,"2":{"3":3}}, {"2":{"3":4}});
+     * > 
+     * {
+            "1": 1,
+            "2": {
+                "3": 4
+            }
+        }
+     */
+	assign<T1, T2 extends object, T3 extends boolean>(
+		target: T1,
+		source: T2,
+		isAdd?: T3
+	): T3 extends true ? T1 & T2 : T1;
+	assign(target = {}, source = {}, isAdd = false) {
+		let UtilsContext = this;
+		if (Array.isArray(source)) {
+			let canTraverse = source.filter((item) => {
+				return typeof item === "object";
+			});
+			if (!canTraverse.length) {
+				return source;
+			}
+		}
+		if (isAdd) {
+			for (const sourceKeyName in source) {
+				const targetKeyName = sourceKeyName;
+				let targetValue = (target as any)[targetKeyName];
+				let sourceValue = (source as any)[sourceKeyName];
+				if (
+					sourceKeyName in target &&
+					typeof sourceValue === "object" &&
+					!UtilsContext.isDOM(sourceValue)
+				) {
+					/* 源端的值是object类型，且不是元素节点 */
+					(target as any)[sourceKeyName] = UtilsContext.assign(
+						targetValue,
+						sourceValue,
+						isAdd
+					);
+					continue;
+				}
+				(target as any)[sourceKeyName] = sourceValue;
+			}
+		} else {
+			for (const targetKeyName in target) {
+				if (targetKeyName in source) {
+					let targetValue = (target as any)[targetKeyName];
+					let sourceValue = (source as any)[targetKeyName];
+					if (
+						typeof sourceValue === "object" &&
+						!UtilsContext.isDOM(sourceValue) &&
+						Object.keys(sourceValue).length
+					) {
+						/* 源端的值是object类型，且不是元素节点 */
+						(target as any)[targetKeyName] = UtilsContext.assign(
+							targetValue,
+							sourceValue,
+							isAdd
+						);
+						continue;
+					}
+					/* 直接赋值 */
+					(target as any)[targetKeyName] = sourceValue;
+				}
+			}
+		}
+
+		return target;
+	}
+	/**
+	 * 异步替换字符串
+	 * @param string 需要被替换的目标字符串
+	 * @param pattern 正则匹配模型
+	 * @param asyncFn 异步获取的函数
+	 */
+	asyncReplaceAll(
+		string: string,
+		pattern: RegExp | string,
+		asyncFn: (item: string) => Promise<string>
+	): Promise<string>;
+	async asyncReplaceAll(
+		string: string,
+		pattern: RegExp | string,
+		asyncFn: (item: string) => Promise<string>
+	) {
+		let UtilsContext = this;
+		if (typeof string !== "string") {
+			throw new TypeError("string必须是字符串");
+		}
+		if (typeof asyncFn !== "function") {
+			throw new TypeError("asyncFn必须是函数");
+		}
+		let reg;
+		if (typeof pattern === "string") {
+			reg = new RegExp(UtilsContext.parseStringToRegExpString(pattern), "g");
+		} else if (pattern instanceof RegExp) {
+			if (!pattern.global) {
+				throw new TypeError("pattern必须是全局匹配");
+			}
+			reg = new RegExp(pattern);
+		} else {
+			throw new TypeError("pattern必须是正则对象");
+		}
+		let result = [];
+		let match;
+		let lastIndex = 0;
+		while ((match = reg.exec(string)) !== null) {
+			/* 异步获取匹配对应的字符串 */
+			const item = asyncFn(match[0]);
+			/* 获取该匹配项和上一个匹配项的中间的字符串 */
+			const prefix = string.slice(lastIndex, match.index);
+			lastIndex = match.index + match[0].length;
+			result.push(item);
+			result.push(prefix);
+		}
+		result.push(string.slice(lastIndex));
+		/* 等待所有异步完成 */
+		result = await Promise.all(result);
+		return result.join("");
+	}
+	/**
+	 * ajax劫持库，支持xhr和fetch劫持。
+	 * + 来源：https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
+	 * + 作者：cxxjackie
+	 * + 版本：1.4.1
+	 * + 文档：https://scriptcat.org/zh-CN/script-show-page/637/
+	 */
+	ajaxHooker: UtilsAjaxHookResult = ajaxHooker;
+	/**
+	 * 根据坐标点击canvas元素的内部位置
+	 * @param canvasElement 画布元素
+	 * @param clientX X坐标，默认值0
+	 * @param clientY Y坐标，默认值0
+	 * @param view 触发的事件目标
+	 */
+	canvasClickByPosition(
+		canvasElement: HTMLCanvasElement,
+		clientX?: number | string,
+		clientY?: number | string,
+		view?: Window & typeof globalThis
+	): void;
+	canvasClickByPosition(
+		canvasElement: HTMLCanvasElement,
+		clientX = 0,
+		clientY = 0,
+		view = globalThis
+	) {
+		if (!(canvasElement instanceof HTMLCanvasElement)) {
+			throw new Error(
+				"Utils.canvasClickByPosition 参数canvasElement必须是canvas元素"
+			);
+		}
+		clientX = parseInt(clientX.toString());
+		clientY = parseInt(clientY.toString());
+		const eventInit: MouseEventInit = {
+			cancelBubble: true,
+			cancelable: true,
+			clientX: clientX,
+			clientY: clientY,
+			// @ts-ignore
+			view: view,
+			detail: 1,
+		};
+		canvasElement.dispatchEvent(new MouseEvent("mousedown", eventInit));
+		canvasElement.dispatchEvent(new MouseEvent("mouseup", eventInit));
+	}
+	/**
+	 * 【手机】检测点击的地方是否在该元素区域内
+	 * @param element 需要检测的元素
+	 * @returns
+	 * + true 点击在元素上
+	 * + false 未点击在元素上
+	 * @example
+	 * Utils.checkUserClickInNode(document.querySelector(".xxx"));
+	 * > false
+	 **/
+	checkUserClickInNode(element: Element | Node | HTMLElement): boolean;
+	checkUserClickInNode(element: Element | Node | HTMLElement) {
+		let UtilsContext = this;
+		if (!UtilsContext.isDOM(element)) {
+			throw new Error(
+				"Utils.checkUserClickInNode 参数 targetNode 必须为 Element|Node 类型"
+			);
+		}
+		let mouseClickPosX = Number(
+			(window!.event as any).clientX.toString()
+		); /* 鼠标相对屏幕横坐标 */
+		let mouseClickPosY = Number(
+			(window!.event as any).clientY.toString()
+		); /* 鼠标相对屏幕纵坐标 */
+		let elementPosXLeft = Number(
+			(element as HTMLElement).getBoundingClientRect().left
+		); /* 要检测的元素的相对屏幕的横坐标最左边 */
+		let elementPosXRight = Number(
+			(element as HTMLElement).getBoundingClientRect().right
+		); /* 要检测的元素的相对屏幕的横坐标最右边 */
+		let elementPosYTop = Number(
+			(element as HTMLElement).getBoundingClientRect().top
+		); /* 要检测的元素的相对屏幕的纵坐标最上边 */
+		let elementPosYBottom = Number(
+			(element as HTMLElement).getBoundingClientRect().bottom
+		); /* 要检测的元素的相对屏幕的纵坐标最下边 */
+		let clickNodeHTML = (window.event as any).target.innerHTML as string;
+		if (
+			mouseClickPosX >= elementPosXLeft &&
+			mouseClickPosX <= elementPosXRight &&
+			mouseClickPosY >= elementPosYTop &&
+			mouseClickPosY <= elementPosYBottom
+		) {
+			return true;
+		} else if (
+			clickNodeHTML &&
+			(element as HTMLElement).innerHTML.includes(clickNodeHTML)
+		) {
+			/* 这种情况是应对在界面中隐藏的元素，getBoundingClientRect获取的都是0 */
+			return true;
+		} else {
+			return false;
+		}
+	}
+	/**
+	 * 复制formData数据
+	 * @param formData 需要clone的数据
+	 */
+	cloneFormData<T extends FormData>(formData: T): T;
+	cloneFormData<T extends FormData>(formData: T) {
+		let clonedFormData = new FormData();
+		for (let [key, value] of (formData as any).entries()) {
+			clonedFormData.append(key, value);
+		}
+		return clonedFormData;
+	}
+	/**
+	 * 函数重载实现
+	 * @example
+	 * let getUsers = Utils.createOverload();
+	 * getUsers.addImpl("",()=>{
+	 *    console.log("无参数");
+	 * });
+	 *
+	 * getUsers.addImpl("boolean",()=>{
+	 *    console.log("boolean");
+	 * });
+	 *
+	 * getUsers.addImpl("string",()=>{
+	 *    console.log("string");
+	 * });
+	 *
+	 * getUsers.addImpl("number","string",()=>{
+	 *    console.log("number string");
+	 * });
+	 */
+	createOverload(): {
+		/**
+		 * 前面的参数都是字符串，最后一个参数是函数
+		 */
+		addImpl<T extends JSTypeNames[]>(
+			...args: [...T, (...args: ArgsType<T>) => any]
+		): void;
+	};
+	createOverload(): {
+		/**
+		 * 前面的参数都是字符串，最后一个参数是函数
+		 */
+		addImpl<T extends JSTypeNames[]>(
+			...args: [...T, (...args: ArgsType<T>) => any]
+		): void;
+	} {
+		let fnMap = new Map();
+		function overload(this: any, ...args: any[]) {
+			let key = args.map((it) => typeof it).join(",");
+			let fn = fnMap.get(key);
+			if (!fn) {
+				throw new TypeError("没有找到对应的实现");
+			}
+			return fn.apply(this, args);
+		}
+		overload.addImpl = function (...args: any[]) {
+			let fn = args.pop();
+			if (typeof fn !== "function") {
+				throw new TypeError("最后一个参数必须是函数");
+			}
+			let key = args.join(",");
+			fnMap.set(key, fn);
+		};
+		return overload;
+	}
+	/**
+	 * 颜色转换
+	 * @returns
+	 */
+	ColorConversion() {
+		return new ColorConversion();
+	}
+	/**
+	 * 深拷贝
+	 * @param obj 对象
+	 */
+	deepClone<T extends object | undefined | null>(obj?: T): T;
+	deepClone<T extends object | undefined | null>(obj?: T) {
+		let UtilsContext = this;
+		if (obj === void 0) return void 0;
+		if (obj === null) return null;
+		let clone = obj instanceof Array ? [] : {};
+		for (const [key, value] of Object.entries(obj)) {
+			(clone as any)[key] =
+				typeof value === "object" ? UtilsContext.deepClone(value) : value;
+		}
+		return clone;
+	}
+	/**
+	 * 防抖函数
+	 * @param fn 需要触发的回调
+	 * @param delay 防抖判定时间(毫秒)，默认是0ms
+	 */
+	debounce<A extends any[], R>(
+		fn: (...args: A) => R,
+		delay?: number
+	): (...args: A) => void;
+	debounce<A extends any[], R>(fn: (...args: A) => R, delay = 0) {
+		let timer: number = null as any;
+		const context = this;
+		return function (...args: A) {
+			clearTimeout(timer);
+			timer = setTimeout(function () {
+				fn.apply(context, args);
+			}, delay);
+		};
+	}
+	/**
+	 * 删除某个父元素，父元素可能在上层或上上层或上上上层...
+	 * @param element 当前元素
+	 * @param targetSelector 判断是否满足父元素，参数为当前处理的父元素，满足返回true，否则false
+	 * @returns
+	 * + true 已删除
+	 * + false 未删除
+	 * @example
+	 * Utils.deleteParentNode(document.querySelector("a"),".xxx");
+	 * > true
+	 **/
+	deleteParentNode(
+		element: Node | HTMLElement | Element | null,
+		targetSelector: string
+	): boolean;
+	deleteParentNode(
+		element: Node | HTMLElement | Element | null,
+		targetSelector: string
+	) {
+		let UtilsContext = this;
+		if (element == null) {
+			return;
+		}
+		if (!UtilsContext.isDOM(element)) {
+			throw new Error(
+				"Utils.deleteParentNode 参数 target 必须为 Node|HTMLElement 类型"
+			);
+		}
+		if (typeof targetSelector !== "string") {
+			throw new Error(
+				"Utils.deleteParentNode 参数 targetSelector 必须为 string 类型"
+			);
+		}
+		let result = false;
+		let needRemoveDOM = (element as HTMLElement).closest(targetSelector);
+		if (needRemoveDOM) {
+			needRemoveDOM.remove();
+			result = true;
+		}
+		return result;
+	}
+
+	/**
+	 * 字典
+	 * @example
+	 * let dictionary = new Utils.Dictionary();
+	 * let dictionary2 = new Utils.Dictionary();
+	 * dictionary.set("test","111");
+	 * dictionary.get("test");
+	 * > '111'
+	 * dictionary.has("test");
+	 * > true
+	 * dictionary.concat(dictionary2);
+	 **/
+	Dictionary = UtilsDictionary;
+	/**
+	 * 主动触发事件
+	 * @param element 元素
+	 * @param eventName 事件名称，可以是字符串，也可是字符串格式的列表
+	 * @param details （可选）赋予触发的Event的额外属性
+	 * + true 使用Proxy代理Event并设置获取isTrusted永远为True
+	 * + false (默认) 不对Event进行Proxy代理
+	 * @example
+	 * Utils.dispatchEvent(document.querySelector("input","input"))
+	 */
+	dispatchEvent(
+		element: HTMLElement | Document,
+		eventName: DOMUtils_EventType | DOMUtils_EventType[],
+		details?: UtilsNestedObjectWithToString<any>
+	): void;
+	/**
+	 * 主动触发事件
+	 * @param element 元素
+	 * @param eventName 事件名称，可以是字符串，也可是字符串格式的列表
+	 * @param details （可选）赋予触发的Event的额外属性
+	 * + true 使用Proxy代理Event并设置获取isTrusted永远为True
+	 * + false (默认) 不对Event进行Proxy代理
+	 * @example
+	 * Utils.dispatchEvent(document.querySelector("input","input"))
+	 */
+	dispatchEvent(
+		element: HTMLElement | Document,
+		eventName: string,
+		details?: UtilsNestedObjectWithToString<any>
+	): void;
+	dispatchEvent(
+		element: HTMLElement | Document,
+		eventName: DOMUtils_EventType | DOMUtils_EventType[] | string,
+		details?: UtilsNestedObjectWithToString<any>
+	) {
+		let eventNameList: string[] = [];
+		if (typeof eventName === "string") {
+			eventNameList = [eventName];
+		}
+		if (Array.isArray(eventName)) {
+			eventNameList = [...eventName];
+		}
+		eventNameList.forEach((_eventName_) => {
+			let event = new Event(_eventName_);
+			if (details) {
+				Object.assign(event, details);
+			}
+			element.dispatchEvent(event);
+		});
+	}
+	/**
+	 * 下载base64格式的数据
+	 * @param base64Data	需要转换的base64数据
+	 * @param fileName	需要保存的文件名
+	 * @param isIFrame （可选）是否使用iframe进行下载
+	 * @example
+	 * Utils.downloadBase64("data:image/jpeg:base64/,xxxxxx");
+	 **/
+	downloadBase64(
+		base64Data: string,
+		fileName: string,
+		isIFrame?: boolean
+	): void;
+	downloadBase64(base64Data: string, fileName: string, isIFrame = false) {
+		if (typeof base64Data !== "string") {
+			throw new Error(
+				"Utils.downloadBase64 参数 base64Data 必须为 string 类型"
+			);
+		}
+		if (typeof fileName !== "string") {
+			throw new Error("Utils.downloadBase64 参数 fileName 必须为 string 类型");
+		}
+		if (isIFrame) {
+			/* 使用iframe */
+			const iframeElement = document.createElement("iframe");
+			iframeElement.style.display = "none";
+			iframeElement.src = base64Data;
+			document.body.appendChild(iframeElement);
+			setTimeout(() => {
+				iframeElement!.contentWindow!.document.execCommand(
+					"SaveAs",
+					true,
+					fileName
+				);
+				document.body.removeChild(iframeElement);
+			}, 100);
+		} else {
+			/* 使用A标签 */
+			const linkElement = document.createElement("a");
+			linkElement.setAttribute("target", "_blank");
+			linkElement.download = fileName;
+			linkElement.href = base64Data;
+			linkElement.click();
+		}
+	}
+
+	/**
+	 * 选中页面中的文字，类似Ctrl+F的选中
+	 * @param str （可选）需要寻找的字符串，默认为空
+	 * @param caseSensitive（可选）默认false
+	 * + true 区分大小写
+	 * + false (默认) 不区分大小写
+	 * @returns
+	 * + true 找到
+	 * + false 未找到
+	 * + undefined 不可使用该Api
+	 * @example
+	 * Utils.findWebPageVisibleText("xxxxx");
+	 * > true
+	 **/
+	findWebPageVisibleText(str?: string, caseSensitive?: boolean): boolean | void;
+	findWebPageVisibleText(str = "", caseSensitive = false) {
+		let TRange = null;
+		let strFound;
+		if ((UtilsCore.globalThis as any).find) {
+			/* CODE FOR BROWSERS THAT SUPPORT window.find */
+			let windowFind = (UtilsCore.self as any).find;
+			strFound = windowFind(str, caseSensitive, true, true, false);
+			if (strFound && self.getSelection && !self.getSelection()!.anchorNode) {
+				strFound = windowFind(str, caseSensitive, true, true, false);
+			}
+			if (!strFound) {
+				strFound = windowFind(str, 0, 1);
+				while (windowFind(str, 0, 1)) continue;
+			}
+		} else if (navigator.appName.indexOf("Microsoft") != -1) {
+			/* EXPLORER-SPECIFIC CODE */
+			if (TRange != null) {
+				TRange = TRange as any;
+				TRange.collapse(false);
+				strFound = TRange.findText(str);
+				if (strFound) TRange.select();
+			}
+			if (TRange == null || strFound == 0) {
+				TRange = (UtilsCore.self.document.body as any).createTextRange();
+				strFound = TRange.findText(str);
+				if (strFound) TRange.select();
+			}
+		} else if (navigator.appName == "Opera") {
+			alert("Opera browsers not supported, sorry...");
+			return;
+		}
+		return strFound ? true : false;
+	}
+	/**
+	 * 定位元素上的字符串，返回一个迭代器
+	 * @param element 目标元素
+	 * @param text 需要定位的字符串
+	 * @param filter （可选）过滤器函数，返回值为true是排除该元素
+	 * @example
+	 * let textIterator = Utils.findElementsWithText(document.documentElement,"xxxx");
+	 * textIterator.next();
+	 * > {value: ?HTMLElement, done: boolean, next: Function}
+	 */
+	findElementsWithText<T extends HTMLElement | Element | Node>(
+		element: T,
+		text: string,
+		filter?: (element: T) => boolean
+	): Generator<HTMLElement | ChildNode, void, any>;
+	*findElementsWithText<T extends HTMLElement | Element | Node>(
+		element: T,
+		text: string,
+		filter?: (element: T) => boolean
+	) {
+		let that = this;
+		if ((element as HTMLElement).outerHTML.includes(text)) {
+			if ((element as HTMLElement).children.length === 0) {
+				let filterResult =
+					typeof filter === "function" ? filter(element) : false;
+				if (!filterResult) {
+					yield element as any;
+				}
+			} else {
+				let textElement = Array.from(element.childNodes).filter(
+					(ele) => ele.nodeType === Node.TEXT_NODE
+				);
+				for (let ele of textElement) {
+					if ((ele as any).textContent.includes(text)) {
+						let filterResult =
+							typeof filter === "function" ? filter(element) : false;
+						if (!filterResult) {
+							yield ele;
+						}
+					}
+				}
+			}
+		}
+
+		for (
+			let index = 0;
+			index < (element as HTMLElement).children.length;
+			index++
+		) {
+			let childElement = (element as HTMLElement).children[index] as any;
+			yield* that.findElementsWithText(childElement, text, filter);
+		}
+	}
+	/**
+	 * 判断该元素是否可见，如果不可见，向上找它的父元素直至找到可见的元素
+	 * @param element
+	 * @example
+	 * let visibleElement = Utils.findVisibleElement(document.querySelector("a.xx"));
+	 * > <HTMLElement>
+	 */
+	findVisibleElement(element: HTMLElement | Element | Node) {
+		let currentElement = element as HTMLElement;
+		while (currentElement) {
+			let elementRect = currentElement.getBoundingClientRect();
+			if (Boolean((elementRect as any).length)) {
+				return currentElement;
+			}
+			currentElement = currentElement.parentElement as any;
+		}
+		return null;
+	}
+	/**
+	 * 格式化byte为KB、MB、GB、TB、PB、EB、ZB、YB、BB、NB、DB
+	 * @param byteSize 字节
+	 * @param addType （可选）是否添加单位
+	 * + true (默认) 添加单位
+	 * + false 不添加单位
+	 * @returns
+	 * + {string} 当addType为true时，且保留小数点末尾2位
+	 * + {number} 当addType为false时，且保留小数点末尾2位
+	 * @example
+	 * Utils.formatByteToSize("812304");
+	 * > '793.27KB'
+	 * @example
+	 * Utils.formatByteToSize("812304",false);
+	 * > 793.27
+	 **/
+	formatByteToSize<T extends boolean>(
+		byteSize: number | string,
+		addType?: T
+	): T extends true ? string : number;
+	formatByteToSize(byteSize: number | string, addType = true) {
+		byteSize = parseInt(byteSize.toString());
+		if (isNaN(byteSize)) {
+			throw new Error("Utils.formatByteToSize 参数 byteSize 格式不正确");
+		}
+		let result = 0;
+		let resultType = "KB";
+		let sizeData: UtilsNestedObjectWithToString<number> = {};
+		sizeData.B = 1;
+		sizeData.KB = 1024;
+		sizeData.MB = sizeData.KB * sizeData.KB;
+		sizeData.GB = sizeData.MB * sizeData.KB;
+		sizeData.TB = sizeData.GB * sizeData.KB;
+		sizeData.PB = sizeData.TB * sizeData.KB;
+		sizeData.EB = sizeData.PB * sizeData.KB;
+		sizeData.ZB = sizeData.EB * sizeData.KB;
+		sizeData.YB = sizeData.ZB * sizeData.KB;
+		sizeData.BB = sizeData.YB * sizeData.KB;
+		sizeData.NB = sizeData.BB * sizeData.KB;
+		sizeData.DB = sizeData.NB * sizeData.KB;
+		for (let key in sizeData) {
+			result = byteSize / sizeData[key];
+			resultType = key;
+			if (sizeData.KB >= result) {
+				break;
+			}
+		}
+		result = result.toFixed(2) as any;
+		result = addType
+			? result + resultType.toString()
+			: (parseFloat(result.toString()) as any);
+		return result;
+	}
+	/**
+	 * 应用场景: 当你想要获取数组形式的元素时，它可能是其它的选择器，那么需要按照先后顺序填入参数
+	 * 第一个是优先级最高的，依次下降，如果都没有，返回空列表
+	 * 支持document.querySelectorAll、$("")、()=>{return document.querySelectorAll("")}
+	 * @param NodeList
+	 * @example
+	 * Utils.getNodeListValue(
+	 *  document.querySelectorAll("div.xxx"),
+	 *  document.querySelectorAll("a.xxx")
+	 * );
+	 * > [...div,div,div]
+	 * @example
+	 * Utils.getNodeListValue(divGetFunction,aGetFunction);
+	 * > [...div,div,div]
+	 */
+	getNodeListValue(...args: (NodeList | (() => HTMLElement))[]): HTMLElement[];
+	getNodeListValue(...args: (NodeList | (() => HTMLElement))[]) {
+		let resultArray: HTMLElement[] = [];
+		for (let arg of args) {
+			let value = arg as any;
+			if (typeof arg === "function") {
+				/* 方法 */
+				value = arg();
+			}
+			if (value.length !== 0) {
+				resultArray = [...value];
+				break;
+			}
+		}
+		return resultArray;
+	}
+	/**
+	 * 自动判断N个参数，获取非空的值，如果都是空，返回最后一个值
+	 */
+	getNonNullValue(...args: any[]): any;
+	getNonNullValue(...args: any[]) {
+		let resultValue = args[args.length - 1];
+		let UtilsContext = this;
+		for (const argValue of args) {
+			if (UtilsContext.isNotNull(argValue)) {
+				resultValue = argValue;
+				break;
+			}
+		}
+		return resultValue;
+	}
+	/**
+	 * 获取格式化后的时间
+	 * @param text （可选）需要格式化的字符串或者时间戳，默认：new Date()
+	 * @param formatType （可选）格式化成的显示类型，默认：yyyy-MM-dd HH:mm:ss
+	 * + yyyy 年
+	 * + MM 月
+	 * + dd 天
+	 * + HH 时 (24小时制)
+	 * + hh 时 (12小时制)
+	 * + mm 分
+	 * + ss 秒
+	 * @returns {string}	返回格式化后的时间
+	 * @example
+	 * Utils.formatTime("2022-08-21 23:59:00","HH:mm:ss");
+	 * > '23:59:00'
+	 * @example
+	 * Utils.formatTime(1899187424988,"HH:mm:ss");
+	 * > '15:10:13'
+	 * @example
+	 * Utils.formatTime()
+	 * > '2023-1-1 00:00:00'
+	 **/
+	formatTime(
+		text?: string | number | Date,
+		formatType?:
+			| "yyyy-MM-dd HH:mm:ss"
+			| "yyyy/MM/dd HH:mm:ss"
+			| "yyyy年MM月dd日 HH时mm分ss秒"
+			| "yyyyMMdd"
+			| "yyyy_MM_dd_HH_mm_ss"
+			| "yyyy年MM月dd日 hh:mm:ss"
+			| "yyyy-MM-dd"
+			| "HH:mm:ss"
+	): string;
+	formatTime(text = new Date(), formatType = "yyyy-MM-dd HH:mm:ss") {
+		let time = text == null ? new Date() : new Date(text);
+		/**
+		 * 校验时间补0
+		 * @param timeNum
+		 * @returns
+		 */
+		function checkTime(timeNum: number) {
+			if (timeNum < 10) return "0" + timeNum;
+			return timeNum;
+		}
+
+		/**
+		 * 时间制修改 24小时制转12小时制
+		 * @param hourNum 小时
+		 * @returns
+		 */
+		function timeSystemChange(hourNum: number) {
+			return hourNum > 12 ? hourNum - 12 : hourNum;
+		}
+
+		let timeRegexp = {
+			yyyy: time.getFullYear(),
+			/* 年 */
+			MM: checkTime(time.getMonth() + 1),
+			/* 月 */
+			dd: checkTime(time.getDate()),
+			/* 日 */
+			HH: checkTime(time.getHours()),
+			/* 时 (24小时制) */
+			hh: checkTime(timeSystemChange(time.getHours())),
+			/* 时 (12小时制) */
+			mm: checkTime(time.getMinutes()),
+			/* 分 */
+			ss: checkTime(time.getSeconds()),
+			/* 秒 */
+		};
+		Object.keys(timeRegexp).forEach(function (key) {
+			let replaecRegexp = new RegExp(key, "g");
+			formatType = formatType.replace(replaecRegexp, (timeRegexp as any)[key]);
+		});
+		return formatType;
+	}
+	/**
+	 * 字符串格式的时间转时间戳
+	 * @param text	字符串格式的时间，例如：
+	 * + 2022-11-21 00:00:00
+	 * + 00:00:00
+	 * @returns 返回时间戳
+	 * @example
+	 * Utils.formatToTimeStamp("2022-11-21 00:00:00");
+	 * > 1668960000000
+	 **/
+	formatToTimeStamp(text: string): number;
+	formatToTimeStamp(text: string) {
+		/* 把字符串格式的时间（完整，包括日期和时间）格式化成时间 */
+		if (typeof text !== "string") {
+			throw new Error("Utils.formatToTimeStamp 参数 text 必须为 string 类型");
+		}
+		if (text.length === 8) {
+			/* 该字符串只有时分秒 */
+			let today = new Date();
+			text =
+				today.getFullYear() +
+				"-" +
+				(today.getMonth() + 1) +
+				"-" +
+				today.getDate() +
+				" " +
+				text;
+		}
+		text = text.substring(0, 19);
+		text = text.replace(/-/g, "/");
+		let timestamp = new Date(text).getTime();
+		return timestamp;
+	}
+	/**
+	 * gbk格式的url编码,来自https://greasyfork.org/zh-CN/scripts/427726-gbk-url-js
+	 * @example
+	 * let gbkEncoder = new Utils.GBKEncoder();
+	 * gbkEncoder.encode("测试");
+	 * > '%B2%E2%CA%D4'
+	 * gbkEncoder.decode("%B2%E2%CA%D4");
+	 * > 测试
+	 */
+	GBKEncoder = GBKEncoder;
+	/**
+	 * 获取 transitionend 的在各个浏览器的兼容名
+	 */
+	getTransitionEndNameList() {
+		return [
+			"webkitTransitionEnd",
+			"mozTransitionEnd",
+			"MSTransitionEnd",
+			"otransitionend",
+			"transitionend",
+		];
+	}
+	/**
+	 * 获取 animationend 的在各个浏览器的兼容名
+	 */
+	getAnimationEndNameList() {
+		return [
+			"webkitAnimationEnd",
+			"mozAnimationEnd",
+			"MSAnimationEnd",
+			"oanimationend",
+			"animationend",
+		];
+	}
+	/**
+	 * 获取NodeList或Array对象中的最后一个的值
+	 * @param targetObj
+	 * @returns
+	 * @example
+	 * Utils.getArrayLastValue(document.querySelectorAll("div"));
+	 * > div
+	 * @example
+	 * Utils.getArrayLastValue([1,2,3,4,5]);
+	 * > 5
+	 */
+	getArrayLastValue<R extends any>(targetObj: NodeList | any[]): R;
+	getArrayLastValue(targetObj: NodeList | any[]) {
+		return targetObj[targetObj.length - 1];
+	}
+	/**
+	 * 应用场景: 当想获取的元素可能是不同的选择器的时候，按顺序优先级获取
+	 * 参数类型可以是Element或者是Function
+	 * @returns 如果都没有的话，返回null
+	 * @example
+	 * // 如果a.aaa不存在的话，取a.bbb，这里假设a.aaa不存在
+	 * Utils.getArrayRealValue(document.querySelector("a.aaa"),document.querySelector("a.bbb"));
+	 * > a.bbb
+	 * @example
+	 * Utils.getArrayRealValue(()=>{return document.querySelector("a.aaa").href},()=>{document.querySelector("a.bbb").getAttribute("data-href")});
+	 * > javascript:;
+	 */
+	getArrayRealValue(...args: (NodeList | (() => HTMLElement))[]): any;
+	getArrayRealValue(...args: (NodeList | (() => HTMLElement))[]) {
+		let result = null;
+		for (let arg of args) {
+			if (typeof arg === "function") {
+				/* 方法 */
+				(arg as any) = arg();
+			}
+			if (arg != null) {
+				result = arg;
+				break;
+			}
+		}
+		return result;
+	}
+	/**
+	 * 获取天数差异，如何获取某个时间与另一个时间相差的天数
+	 * @param timestamp1 （可选）时间戳(毫秒|秒)，不区分哪个更大，默认为：Date.now()
+	 * @param timestamp2 （可选）时间戳(毫秒|秒)，不区分哪个更大，默认为：Date.now()
+	 * @param type （可选）返回的数字的表达的类型，比如：年、月、天、时、分、秒、auto，默认天
+	 * @example
+	 * Utils.getDaysDifference(new Date().getTime());
+	 * > 0
+	 * @example
+	 * Utils.getDaysDifference(new Date().getTime(),undefined,"秒");
+	 * > 0
+	 */
+	getDaysDifference(
+		timestamp1?: number,
+		timestamp2?: number,
+		type?: "auto"
+	): string;
+	/**
+	 * 获取天数差异，如何获取某个时间与另一个时间相差的天数
+	 * @param timestamp1 （可选）时间戳(毫秒|秒)，不区分哪个更大，默认为：Date.now()
+	 * @param timestamp2 （可选）时间戳(毫秒|秒)，不区分哪个更大，默认为：Date.now()
+	 * @param type （可选）返回的数字的表达的类型，比如：年、月、天、时、分、秒、auto，默认天
+	 * @example
+	 * Utils.getDaysDifference(new Date().getTime());
+	 * > 0
+	 * @example
+	 * Utils.getDaysDifference(new Date().getTime(),undefined,"秒");
+	 * > 0
+	 */
+	getDaysDifference(
+		timestamp1?: number,
+		timestamp2?: number,
+		type?: "年" | "月" | "天" | "时" | "分" | "秒"
+	): number;
+	getDaysDifference(
+		timestamp1 = Date.now(),
+		timestamp2 = Date.now(),
+		type = "天"
+	): number | string {
+		type = type.trim();
+		if (timestamp1.toString().length === 10) {
+			timestamp1 = timestamp1 * 1000;
+		}
+		if (timestamp2.toString().length === 10) {
+			timestamp2 = timestamp2 * 1000;
+		}
+		let smallTimeStamp = timestamp1 > timestamp2 ? timestamp2 : timestamp1;
+		let bigTimeStamp = timestamp1 > timestamp2 ? timestamp1 : timestamp2;
+		let oneSecond = 1000; /* 一秒的毫秒数 */
+		let oneMinute = 60 * oneSecond; /* 一分钟的毫秒数 */
+		let oneHour = 60 * oneMinute; /* 一小时的毫秒数 */
+		let oneDay = 24 * oneHour; /* 一天的毫秒数 */
+		let oneMonth = 30 * oneDay; /* 一个月的毫秒数(30天) */
+		let oneYear = 12 * oneMonth; /* 一年的毫秒数 */
+		let bigDate = new Date(bigTimeStamp);
+		let smallDate = new Date(smallTimeStamp);
+		let remainderValue = 1;
+		if (type === "年") {
+			remainderValue = oneYear;
+		} else if (type === "月") {
+			remainderValue = oneMonth;
+		} else if (type === "天") {
+			remainderValue = oneDay;
+		} else if (type === "时") {
+			remainderValue = oneHour;
+		} else if (type === "分") {
+			remainderValue = oneMinute;
+		} else if (type === "秒") {
+			remainderValue = oneSecond;
+		}
+		let diffValue = Math.round(
+			Math.abs(((bigDate as any) - (smallDate as any)) / remainderValue)
+		);
+		if (type === "auto") {
+			let timeDifference = bigTimeStamp - smallTimeStamp;
+			diffValue = Math.floor(timeDifference / (24 * 3600 * 1000));
+			if (diffValue > 0) {
+				(diffValue as any) = diffValue + "天";
+			} else {
+				/* 计算出小时数 */
+				let leave1 =
+					timeDifference % (24 * 3600 * 1000); /* 计算天数后剩余的毫秒数 */
+				let hours = Math.floor(leave1 / (3600 * 1000));
+				if (hours > 0) {
+					(diffValue as any) = hours + "小时";
+				} else {
+					/* 计算相差分钟数 */
+					let leave2 = leave1 % (3600 * 1000); /* 计算小时数后剩余的毫秒数 */
+					let minutes = Math.floor(leave2 / (60 * 1000));
+					if (minutes > 0) {
+						(diffValue as any) = minutes + "分钟";
+					} else {
+						/* 计算相差秒数 */
+						let leave3 = leave2 % (60 * 1000); /* 计算分钟数后剩余的毫秒数 */
+						let seconds = Math.round(leave3 / 1000);
+						(diffValue as any) = seconds + "秒";
+					}
+				}
+			}
+		}
+		return diffValue;
+	}
+	/**
+	 * 获取元素的选择器字符串
+	 * @param element
+	 * @example
+	 * Utils.getElementSelector(document.querySelector("a"))
+	 * > '.....'
+	 */
+	getElementSelector(element: HTMLElement): string;
+	getElementSelector(element: HTMLElement): string {
+		let UtilsContext = this;
+		// @ts-ignore
+		if (!element) return;
+		// @ts-ignore
+		if (!element.parentElement) return;
+		/* 如果元素有id属性，则直接返回id选择器 */
+		if (element.id) return "#" + element.id;
+
+		/* 递归地获取父元素的选择器 */
+		let selector = UtilsContext.getElementSelector(element.parentElement);
+		if (!selector) {
+			return element.tagName.toLowerCase();
+		}
+		/* 如果有多个相同类型的兄弟元素，则需要添加索引 */
+		if (element.parentElement.querySelectorAll(element.tagName).length > 1) {
+			let index =
+				Array.prototype.indexOf.call(element.parentElement.children, element) +
+				1;
+			selector +=
+				" > " + element.tagName.toLowerCase() + ":nth-child(" + index + ")";
+		} else {
+			selector += " > " + element.tagName.toLowerCase();
+		}
+		return selector;
+	}
+	/**
+	 * 获取最大值
+	 * @example
+	 * Utils.getMaxValue(1,3,5,7,9)
+	 * > 9
+	 */
+	getMaxValue(...args: number[]): number;
+	/**
+	 * 获取最大值
+	 * @example
+	 * Utils.getMaxValue([1,3,5])
+	 * > 5
+	 */
+	getMaxValue(val: number[]): number;
+	/**
+	 * 获取最大值
+	 * @example
+	 * Utils.getMaxValue({1:123,2:345,3:456},(key,value)=>{return parseInt(value)})
+	 * > 456
+	 */
+	getMaxValue(
+		val: UtilsNestedObjectWithToString<number>,
+		handler: (key: any, value: any) => number
+	): number;
+	/**
+	 * 获取最大值
+	 * @example
+	 * Utils.getMaxValue([{1:123},{2:345},{3:456}],(index,value)=>{return parseInt(index)})
+	 * > 2
+	 */
+	getMaxValue(...args: any[]): number {
+		let result = [...args];
+		let newResult: number[] = [];
+		if (result.length === 0) {
+			// @ts-ignore
+			return;
+		}
+		if (result.length > 1) {
+			if (
+				result.length === 2 &&
+				typeof result[0] === "object" &&
+				typeof result[1] === "function"
+			) {
+				let data = result[0];
+				let handleDataFunc = result[1];
+				Object.keys(data).forEach((keyName) => {
+					newResult = [...newResult, handleDataFunc(keyName, data[keyName])];
+				});
+			} else {
+				result.forEach((item) => {
+					if (!isNaN(parseFloat(item))) {
+						newResult = [...newResult, parseFloat(item)];
+					}
+				});
+			}
+			return Math.max(...newResult);
+		} else {
+			result[0].forEach((item: any) => {
+				if (!isNaN(parseFloat(item))) {
+					newResult = [...newResult, parseFloat(item)];
+				}
+			});
+			return Math.max(...newResult);
+		}
+	}
+	/**
+	 * 获取页面中最大的z-index
+	 * @param deviation 获取最大的z-index值的偏移，默认是+1
+	 * @example
+	 * Utils.getMaxZIndex();
+	 * > 1001
+	 **/
+	getMaxZIndex(deviation?: number): number;
+	getMaxZIndex(deviation = 1): number {
+		let nodeIndexList: number[] = [];
+		deviation = Number.isNaN(deviation) ? 1 : deviation;
+		document.querySelectorAll("*").forEach((element) => {
+			let nodeStyle = window.getComputedStyle(element);
+			/* 不对position为static和display为none的元素进行获取它们的z-index */
+			if (nodeStyle.position !== "static" && nodeStyle.display !== "none") {
+				nodeIndexList = nodeIndexList.concat(parseInt(nodeStyle.zIndex));
+			}
+		});
+		/* 过滤非Boolean类型 */
+		nodeIndexList = nodeIndexList.filter(Boolean);
+		let currentMaxZIndex = nodeIndexList.length
+			? Math.max(...nodeIndexList)
+			: 0;
+		return currentMaxZIndex + deviation;
+	}
+	/**
+	 * 获取最小值
+	 * @example
+	 * Utils.getMinValue(1,3,5,7,9)
+	 * > 1
+	 */
+	getMinValue(...args: number[]): number;
+	/**
+	 * 获取最小值
+	 * @example
+	 * Utils.getMinValue([1,3,5])
+	 * > 1
+	 */
+	getMinValue(val: number[]): number;
+	/**
+	 * 获取最小值
+	 * @example
+	 * Utils.getMinValue({1:123,2:345,3:456},(key,value)=>{return parseInt(value)})
+	 * > 123
+	 */
+	getMinValue(
+		val: UtilsNestedObjectWithToString<number>,
+		handler: (key: any, value: any) => number
+	): number;
+	/**
+	 * 获取最小值
+	 * @example
+	 * Utils.getMinValue([{1:123},{2:345},{3:456}],(index,value)=>{return parseInt(index)})
+	 * > 0
+	 */
+	getMinValue(
+		val: UtilsNestedObjectWithToString<number>[],
+		handler: (index: number, value: any) => number
+	): number;
+	getMinValue(...args: any[]): number {
+		let result = [...args];
+		let newResult: number[] = [];
+		if (result.length === 0) {
+			// @ts-ignore
+			return;
+		}
+		if (result.length > 1) {
+			if (
+				result.length === 2 &&
+				typeof result[0] === "object" &&
+				typeof result[1] === "function"
+			) {
+				let data = result[0];
+				let handleDataFunc = result[1];
+				Object.keys(data).forEach((keyName) => {
+					newResult = [...newResult, handleDataFunc(keyName, data[keyName])];
+				});
+			} else {
+				result.forEach((item) => {
+					if (!isNaN(parseFloat(item))) {
+						newResult = [...newResult, parseFloat(item)];
+					}
+				});
+			}
+			return Math.min(...newResult);
+		} else {
+			result[0].forEach((item: any) => {
+				if (!isNaN(parseFloat(item))) {
+					newResult = [...newResult, parseFloat(item)];
+				}
+			});
+			return Math.min(...newResult);
+		}
+	}
+	/**
+	 * 获取随机的安卓手机User-Agent
+	 * @example
+	 * Utils.getRandomAndroidUA();
+	 * > 'Mozilla/5.0 (Linux; Android 10; MI 13 Build/OPR1.170623.027; wv) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.3490.40 Mobile Safari/537.36'
+	 **/
+	getRandomAndroidUA(): string;
+	getRandomAndroidUA(): string {
+		let UtilsContext = this;
+		let mobileNameList = [
+			"LDN-LX3",
+			"RNE-L03",
+			"ASUS_X00ID Build/NMF26F",
+			"WAS-LX3",
+			"PRA-LX3",
+			"MYA-L03",
+			"Moto G Play",
+			"Moto C Build/NRD90M.063",
+			"Redmi Note 4 Build/NRD90M",
+			"HUAWEI VNS-L21 Build/HUAWEIVNS-L21",
+			"VTR-L09",
+			"TRT-LX3",
+			"M2003J15SC Build/RP1A.200720.011; wv",
+			"MI 13 Build/OPR1.170623.027; wv",
+		];
+		let androidVersion = UtilsContext.getRandomValue(12, 14);
+		let randomMobile = UtilsContext.getRandomValue(mobileNameList);
+		let chromeVersion1 = UtilsContext.getRandomValue(115, 125);
+		let chromeVersion2 = UtilsContext.getRandomValue(0, 0);
+		let chromeVersion3 = UtilsContext.getRandomValue(2272, 6099);
+		let chromeVersion4 = UtilsContext.getRandomValue(1, 218);
+		return `Mozilla/5.0 (Linux; Android ${androidVersion}; ${randomMobile}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion1}.${chromeVersion2}.${chromeVersion3}.${chromeVersion4} Mobile Safari/537.36`;
+	}
+	/**
+	 * 获取随机值
+	 * @example
+	 * Utils.getRandomValue(1,9,6,99)
+	 * > 6
+	 */
+	getRandomValue<T extends any>(...args: T[]): T;
+	/**
+	 * 获取随机值
+	 * @example
+	 * Utils.getRandomValue([1,2,3])
+	 * > 3
+	 * @example
+	 * Utils.getRandomValue({1:"结果1",2:"结果2",3:"结果3"}})
+	 * > 结果2
+	 */
+	getRandomValue<T extends any>(val: T[] | UtilsNestedObjectWithToString<T>): T;
+	/**
+	 * 获取两个数之间随机值
+	 * @example
+	 * Utils.getRandomValue(1,9)
+	 * > 6
+	 */
+	getRandomValue(val_1: number, val_2: number): number;
+	/**
+	 * 获取随机值
+	 * @example
+	 * Utils.getRandomValue({1:1},{2:2})
+	 * > {1: 1}
+	 */
+	getRandomValue<T extends any>(
+		val_1: UtilsNestedObjectWithToString<T>,
+		val_2: UtilsNestedObjectWithToString<T>
+	): T;
+	getRandomValue(...args: any[]): any {
+		let result = [...args];
+		if (result.length > 1) {
+			if (
+				result.length === 2 &&
+				typeof result[0] === "number" &&
+				typeof result[1] === "number"
+			) {
+				let leftNumber = result[0] > result[1] ? result[1] : result[0];
+				let rightNumber = result[0] > result[1] ? result[0] : result[1];
+				return (
+					Math.round(Math.random() * (rightNumber - leftNumber)) + leftNumber
+				);
+			} else {
+				return result[Math.floor(Math.random() * result.length)];
+			}
+		} else if (result.length === 1) {
+			let paramData = result[0];
+			if (Array.isArray(paramData)) {
+				return paramData[Math.floor(Math.random() * paramData.length)];
+			} else if (
+				typeof paramData === "object" &&
+				Object.keys(paramData).length > 0
+			) {
+				let paramObjDataKey =
+					Object.keys(paramData)[
+						Math.floor(Math.random() * Object.keys(paramData).length)
+					];
+				return paramData[paramObjDataKey];
+			} else {
+				return paramData;
+			}
+		}
+	}
+	/**
+	 * 获取随机的电脑端User-Agent
+	 * + Mozilla/5.0：以前用于Netscape浏览器，目前大多数浏览器UA都会带有
+	 * + Windows NT 13：代表Window11系统
+	 * + Windows NT 10.0：代表Window10系统
+	 * + Windows NT 6.1：代表windows7系统
+	 * + WOW64：Windows-on-Windows 64-bit，32位的应用程序运行于此64位处理器上
+	 * + Win64：64位
+	 * + AppleWebKit/537.36：浏览器内核
+	 * + KHTML：HTML排版引擎
+	 * + like Gecko：这不是Geckeo 浏览器，但是运行起来像Geckeo浏览器
+	 * + Chrome/106.0.5068.19：Chrome版本号
+	 * + Safari/537.36：宣称自己是Safari？
+	 * @returns 返回随机字符串
+	 * @example
+	 * Utils.getRandomPCUA();
+	 * > 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.5068.19 Safari/537.36'
+	 **/
+	getRandomPCUA(): string {
+		let UtilsContext = this;
+		let chromeVersion1 = UtilsContext.getRandomValue(115, 126);
+		let chromeVersion2 = UtilsContext.getRandomValue(0, 0);
+		let chromeVersion3 = UtilsContext.getRandomValue(2272, 6099);
+		let chromeVersion4 = UtilsContext.getRandomValue(1, 218);
+		return `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion1}.${chromeVersion2}.${chromeVersion3}.${chromeVersion4} Safari/537.36`;
+	}
+	/**
+	 * 获取元素上的使用React框架的实例属性，目前包括reactFiber、reactProps、reactEvents、reactEventHandlers、reactInternalInstance
+	 * @param element 需要获取的目标元素
+	 * @returns
+	 * @example
+	 * Utils.getReactObj(document.querySelector("input"))?.reactProps?.onChange({target:{value:"123"}});
+	 */
+	getReactObj(element: HTMLElement | Element): {
+		reactFiber?: AnyObject;
+		reactProps?: AnyObject;
+		reactEvents?: AnyObject;
+		reactEventHandlers?: AnyObject;
+		reactInternalInstance?: AnyObject;
+		reactContainer?: AnyObject;
+	} {
+		let result = {};
+		Object.keys(element).forEach((domPropsName) => {
+			if (domPropsName.startsWith("__react")) {
+				let propsName = domPropsName.replace(/__(.+)\$.+/i, "$1");
+				if (propsName in result) {
+					new Error("重复属性 " + domPropsName);
+				} else {
+					(result as any)[propsName] = (element as any)[domPropsName];
+				}
+			}
+		});
+		return result;
+	}
+	/**
+	 * 获取对象上的Symbol属性，如果没设置keyName，那么返回一个对象，对象是所有遍历到的Symbol对象
+	 * @param target 目标对象
+	 * @param keyName （可选）Symbol名或者Symbol对象
+	 */
+	getSymbol(target: any, keyName?: string | symbol) {
+		if (typeof target !== "object") {
+			throw new TypeError("target不是一个对象");
+		}
+		let objectsSymbols = Object.getOwnPropertySymbols(target);
+		if (typeof keyName === "string") {
+			let findSymbol = objectsSymbols.find((key) => {
+				return key.toString() === keyName;
+			});
+			if (findSymbol) {
+				return target[findSymbol];
+			}
+		} else if (typeof keyName === "symbol") {
+			let findSymbol = objectsSymbols.find((key) => {
+				return key === keyName;
+			});
+			if (findSymbol) {
+				return (target as any)[findSymbol];
+			}
+		} else {
+			let result = {};
+			objectsSymbols.forEach((item) => {
+				(result as any)[item] = target[item];
+			});
+			return result;
+		}
+	}
+	/**
+	 * 获取文本的字符长度
+	 * @param text
+	 * @example
+	 * Utils.getTextLength("测试文本")
+	 * > 12
+	 */
+	getTextLength(text: string): number {
+		let encoder = new TextEncoder();
+		let bytes = encoder.encode(text);
+		return bytes.length;
+	}
+	/**
+	 * 获取文本占据的空间大小，返回自动的单位，如12 Kb,14 K,20 MB，1 GB
+	 * @param text 目标字符串
+	 * @param addType （可选）是否添加单位
+	 * + true (默认) 自动添加单位
+	 * + false 不添加单位
+	 * @example
+	 * Utils.getTextStorageSize("测试文本");
+	 * > '12.00B'
+	 */
+	getTextStorageSize<T extends boolean>(
+		text: string,
+		addType?: T
+	): T extends true ? string : number;
+	getTextStorageSize(text: string, addType = true) {
+		let UtilsContext = this;
+		return UtilsContext.formatByteToSize(
+			UtilsContext.getTextLength(text),
+			addType
+		);
+	}
+	/**
+	 * 获取迅雷协议的Url
+	 * @param url Url链接或者其它信息
+	 */
+	getThunderUrl(url: string): string;
+	getThunderUrl(url: string): string {
+		if (url == null) {
+			throw new TypeError("url不能为空");
+		}
+		if (typeof url !== "string") {
+			throw new TypeError("url必须是string类型");
+		}
+		if (url.trim() === "") {
+			throw new TypeError("url不能为空字符串或纯空格");
+		}
+		return `thunder://${globalThis.btoa("AA" + url + "ZZ")}`;
+	}
+	/**
+     * 对于GM_cookie的兼容写法，当无法使用GM_cookie时可以使用这个,但是并不完全兼容，有些写不出来且限制了httponly是无法访问的
+     * @example
+      let GM_cookie = new Utils.GM_Cookie();
+      GM_cookie.list({name:"xxx_cookie_xxx"},function(cookies,error){
+          if (!error) {
+              console.log(cookies);
+              console.log(cookies.value);
+          } else {
+              console.error(error);
+          }
+      });
+      GM_cookie.set({name:"xxx_cookie_test_xxx",value:"这是Cookie测试值"},function(error){
+          if (error) {
+              console.error(error);
+          } else {
+              console.log('Cookie set successfully.');
+          }
+      })
+      GM_cookie.delete({name:"xxx_cookie_test_xxx"},function(error){
+          if (error) {
+              console.error(error);
+          } else {
+              console.log('Cookie set successfully.');
+          }
+      })
+     **/
+	GM_Cookie = UtilsGMCookie;
+	/**
+     * 注册油猴菜单，要求本地存储的键名不能存在其它键名`GM_Menu_Local_Map`会冲突/覆盖
+     * @example
+      let GM_Menu = new Utils.GM_Menu({
+        data: [
+          {
+            menu_key: "menu_key",
+            text: "测试按钮",
+            enable: true,
+            accessKey: "a",
+            autoClose: false,
+            showText(text, enable) {
+              return "[" + (enable ? "√" : "×") + "]" + text;
+            },
+            callback(data) {
+              console.log("点击菜单，值修改为", data.enable);
+            },
+          },
+        ],
+        autoReload: false,
+        GM_getValue,
+        GM_setValue,
+        GM_registerMenuCommand,
+        GM_unregisterMenuCommand,
+      });
+  
+  
+      // 获取某个菜单项的值
+      GM_Menu.get("menu_key");
+      > true
+  
+      // 获取某个菜单项的开启/关闭后显示的文本
+      GM_Menu.getShowTextValue("menu_key");
+      > √测试按钮
+  
+      // 添加键为menu_key2的菜单项
+      GM_Menu.add({
+        key:"menu_key2",
+        text: "测试按钮2",
+        enable: false,
+        showText(text,enable){
+          return "[" + (enable ? "√" : "×") + "]" + text;
+        },
+        callback(data){
+          console.log("点击菜单，值修改为",data.enable);
+        }
+      });
+      // 使用数组的方式添加多个菜单，如menu_key3、menu_key4
+      GM_Menu.add([
+        {
+          key:"menu_key3",
+          text: "测试按钮3",
+          enable: false,
+          showText(text,enable){
+            return "[" + (enable ? "√" : "×") + "]" + text;
+          },
+          callback(data){
+            console.log("点击菜单，值修改为",data.enable);
+          }
+        },
+        {
+          key:"menu_key4",
+          text: "测试按钮4",
+          enable: false,
+          showText(text,enable){
+            return "[" + (enable ? "√" : "×") + "]" + text;
+          },
+          callback(data){
+            console.log("点击菜单，值修改为",data.enable);
+          }
+        }
+      ]);
+  
+      // 更新键为menu_key的显示文字和点击回调
+      GM_Menu.update({
+        menu_key:{
+          text: "更新后的测试按钮",
+          enable: true,
+          showText(text,enable){
+            return "[" + (enable ? "√" : "×") + "]" + text;
+          },
+          callback(data){
+            console.log("点击菜单更新后的测试按钮，新值修改为",data.enable);
+          }
+        }
+      });
+  
+      // 删除键为menu_key的菜单
+      GM_Menu.delete("menu_key");
+     **/
+	GM_Menu: UtilsGMMenu = GMMenu as any;
+	/**
+     * 基于Function prototype，能够勾住和释放任何函数
+     * 
+     * .hook
+     * + realFunc {string} 用于保存原始函数的函数名称,用于unHook
+     * + hookFunc {string} 替换的hook函数
+     * + context {object} 目标函数所在对象,用于hook非window对象下的函数，如String.protype.slice,carInstance1
+     * + methodName {string} 匿名函数需显式传入目标函数名eg:this.Begin = function(){....};}
+     * 
+     * .unhook
+     * + realFunc {string} 用于保存原始函数的函数名称,用于unHook
+     * + funcName {string} 被Hook的函数名称
+     * + context {object} 目标函数所在对象,用于hook非window对象下的函数，如String.protype.slice,carInstance1
+     * @example
+      let hook = new Utils.Hooks();
+      hook.initEnv();
+      function myFunction(){
+          console.log("我自己需要执行的函数");
+      }
+      function testFunction(){
+          console.log("正常执行的函数");
+      }
+      testFunction.hook(testFunction,myFunction,window);
+     **/
+	Hooks: UtilsHooks = Hooks;
+
+	/**
+     * 为减少代码量和回调，把GM_xmlhttpRequest封装
+     * 文档地址: https://www.tampermonkey.net/documentation.php?ext=iikm
+     * 其中onloadstart、onprogress、onreadystatechange是回调形式，onabort、ontimeout、onerror可以设置全局回调函数
+     * @param _GM_xmlHttpRequest_ 油猴中的GM_xmlhttpRequest
+     * @example
+      let httpx = new Utils.Httpx(GM_xmlhttpRequest);
+      let postResp = await httpx.post({
+        url:url,
+        data:JSON.stringify({
+          test:1
+        }),
+        timeout: 5000
+      });
+      console.log(postResp);
+      > {
+        status: true,
+        data: {responseText: "...", response: xxx,...},
+        msg: "请求完毕",
+        type: "onload",
+      }
+  
+      if(postResp === "onload" && postResp.status){
+      // onload
+      }else if(postResp === "ontimeout"){
+      // ontimeout
+      }
+     * @example
+      // 也可以先配置全局参数
+      let httpx = new Utils.Httpx(GM_xmlhttpRequest);
+      httpx.config({
+        timeout: 5000,
+        async: false,
+        responseType: "html",
+        redirect: "follow",
+      })
+      // 优先级为 默认details < 全局details < 单独的details
+     */
+	Httpx: UtilsHttpx = Httpx;
+	/**
+     * 浏览器端的indexedDB操作封装
+     * @example
+      let db = new Utils.indexedDB('web_DB', 'nav_text')
+      let data = {name:'管理员', roleId: 1, type: 1};
+      db.save('list',data).then((resolve)=>{
+          console.log(resolve,'存储成功')
+      })
+  
+      db.get('list').then((resolve)=>{
+          console.log(resolve,'查询成功')
+      })
+  
+      db.getPaging('list',20,10).then((resolve)=>{
+          console.log(resolve,'查询分页偏移第20，一共10行成功');
+      })
+  
+      db.delete('list').then(resolve=>{
+          console.log(resolve,'删除成功---->>>>>>name')
+      })
+  
+      db.deleteAll().then(resolve=>{
+          console.log(resolve,'清除数据库---->>>>>>name')
+      })
+     **/
+	indexedDB: UtilsIndexedDB = indexedDB;
+	/**
+	 * 判断目标函数是否是Native Code
+	 * @param target
+	 * @returns
+	 * + true 是Native
+	 * + false 不是Native
+	 * @example
+	 * Utils.isNativeFunc(window.location.assign)
+	 * > true
+	 */
+	isNativeFunc(target: Function): boolean;
+	isNativeFunc(target: Function): boolean {
+		return Boolean(
+			target.toString().match(/^function .*\(\) { \[native code\] }$/)
+		);
+	}
+	/**
+	 * 判断当前的位置是否位于页面底部附近
+	 * @param nearValue （可选）判断在页面底部的误差值，默认：50
+	 * @returns
+	 * + true 在底部附近
+	 * + false 不在底部附近
+	 */
+	isNearBottom(nearValue?: number): boolean;
+	isNearBottom(nearValue: number = 50): boolean {
+		var scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+		var windowHeight =
+			window.innerHeight || document.documentElement.clientHeight;
+		var documentHeight = document.documentElement.scrollHeight;
+		return scrollTop + windowHeight >= documentHeight - nearValue;
+	}
+	/**
+	 * 判断对象是否是元素
+	 * @param target
+	 * @returns
+	 * + true 是元素
+	 * + false 不是元素
+	 * @example
+	 * Utils.isDOM(document.querySelector("a"))
+	 * > true
+	 */
+	isDOM(target: any): boolean;
+	isDOM(target: any): boolean {
+		return target instanceof Node;
+	}
+	/**
+	 * 判断浏览器是否支持全屏
+	 */
+	isFullscreenEnabled(): boolean;
+	isFullscreenEnabled(): boolean {
+		return !!(
+			(UtilsCore.document as any).fullscreenEnabled ||
+			(UtilsCore.document as any).webkitFullScreenEnabled ||
+			(UtilsCore.document as any).mozFullScreenEnabled ||
+			(UtilsCore.document as any).msFullScreenEnabled
+		);
+	}
+	/**
+	 * 判断对象是否是jQuery对象
+	 * @param target
+	 * @returns
+	 * + true 是jQuery对象
+	 * + false 不是jQuery对象
+	 * @example
+	 * Utils.isJQuery($("a"))
+	 * > true
+	 */
+	isJQuery(target: any): boolean;
+	isJQuery(target: any): boolean {
+		let result = false;
+		// @ts-ignore
+		if (typeof jQuery === "object" && target instanceof jQuery) {
+			result = true;
+		}
+		if (target == null) {
+			return false;
+		}
+		if (typeof target === "object") {
+			/* 也有种可能，这个jQuery对象是1.8.3版本的，页面中的jQuery是3.4.1版本的 */
+			let jQueryProps = [
+				"add",
+				"addBack",
+				"addClass",
+				"after",
+				"ajaxComplete",
+				"ajaxError",
+				"ajaxSend",
+				"ajaxStart",
+				"ajaxStop",
+				"ajaxSuccess",
+				"animate",
+				"append",
+				"appendTo",
+				"attr",
+				"before",
+				"bind",
+				"blur",
+				"change",
+				"children",
+				"clearQueue",
+				"click",
+				"clone",
+				"closest",
+				"constructor",
+				"contents",
+				"contextmenu",
+				"css",
+				"data",
+				"dblclick",
+				"delay",
+				"delegate",
+				"dequeue",
+				"each",
+				"empty",
+				"end",
+				"eq",
+				"extend",
+				"fadeIn",
+				"fadeOut",
+				"fadeTo",
+				"fadeToggle",
+				"filter",
+				"find",
+				"first",
+				"focus",
+				"focusin",
+				"focusout",
+				"get",
+				"has",
+				"hasClass",
+				"height",
+				"hide",
+				"hover",
+				"html",
+				"index",
+				"init",
+				"innerHeight",
+				"innerWidth",
+				"insertAfter",
+				"insertBefore",
+				"is",
+				"jquery",
+				"keydown",
+				"keypress",
+				"keyup",
+				"last",
+				"load",
+				"map",
+				"mousedown",
+				"mouseenter",
+				"mouseleave",
+				"mousemove",
+				"mouseout",
+				"mouseover",
+				"mouseup",
+				"next",
+				"nextAll",
+				"not",
+				"off",
+				"offset",
+				"offsetParent",
+				"on",
+				"one",
+				"outerHeight",
+				"outerWidth",
+				"parent",
+				"parents",
+				"position",
+				"prepend",
+				"prependTo",
+				"prev",
+				"prevAll",
+				"prevUntil",
+				"promise",
+				"prop",
+				"pushStack",
+				"queue",
+				"ready",
+				"remove",
+				"removeAttr",
+				"removeClass",
+				"removeData",
+				"removeProp",
+				"replaceAll",
+				"replaceWith",
+				"resize",
+				"scroll",
+				"scrollLeft",
+				"scrollTop",
+				"select",
+				"show",
+				"siblings",
+				"slice",
+				"slideDown",
+				"slideToggle",
+				"slideUp",
+				"sort",
+				"splice",
+				"text",
+				"toArray",
+				"toggle",
+				"toggleClass",
+				"trigger",
+				"triggerHandler",
+				"unbind",
+				"width",
+				"wrap",
+			];
+			for (const jQueryPropsName of jQueryProps) {
+				if (!(jQueryPropsName in target)) {
+					result = false;
+					/* console.log(jQueryPropsName); */
+					break;
+				} else {
+					result = true;
+				}
+			}
+		}
+		return result;
+	}
+	/**
+	 * 判断当前设备是否是移动端
+	 * @param userAgent （可选）UA字符串，默认使用当前的navigator.userAgent
+	 * @returns
+	 * + true 是移动端
+	 * + false 不是移动端
+	 * @example
+	 * Utils.isPhone();
+	 * > true
+	 **/
+	isPhone(userAgent?: string): boolean;
+	isPhone(userAgent: string = navigator.userAgent): boolean {
+		return Boolean(/(iPhone|iPad|iPod|iOS|Android|Mobile)/i.test(userAgent));
+	}
+	/**
+	 * 判断传递的字符串是否是由相同的字符组成
+	 * @param targetStr 需要判断的字符串，长度(.length)需要≥2
+	 * @param coefficient 系数（默认:1），某个字符重复的系数大于它那么就是返回true，默认全部
+	 */
+	isSameChars(targetStr: string, coefficient?: number): boolean;
+	isSameChars(targetStr: string, coefficient: number = 1): boolean {
+		if (typeof targetStr !== "string") {
+			throw new TypeError("参数 str 必须是 string 类型");
+		}
+		if (targetStr.length < 2) {
+			return false;
+		}
+		targetStr = targetStr.toLowerCase();
+		const targetCharMap: UtilsNestedObjectWithToString<string> = {};
+		let targetStrLength = 0;
+		for (const char of targetStr) {
+			if (Reflect.has(targetCharMap, char)) {
+				targetCharMap[char]++;
+			} else {
+				targetCharMap[char] = 1;
+			}
+			targetStrLength++;
+		}
+		let result = false;
+		for (const char in targetCharMap) {
+			if (targetCharMap[char] / targetStrLength >= coefficient) {
+				result = true;
+				break;
+			}
+		}
+		return result;
+	}
+	/**
+	 * 判断对象是否不为空
+	 * @returns {boolean}
+	 * + true 不为空
+	 * + false 为空
+	 * @example
+	 * Utils.isNotNull("123");
+	 * > true
+	 */
+	isNotNull(...args: any[]): boolean;
+	isNotNull(...args: any[]): boolean {
+		let UtilsContext = this;
+		return !UtilsContext.isNull.apply(this, args);
+	}
+	/**
+     * 判断对象或数据是否为空
+     * + `String`判空的值，如 ""、"null"、"undefined"、"   "
+     * + `Number`判空的值，如 0
+     * + `Object`判空的值，如 {}、null、undefined
+     * + `Array`(存在属性Symbol.iterator)判空的值，如 []
+     * + `Boolean`判空的值，如false
+     * + `Function`判空的值，如()=>{}、(xxx="")=>{}、function(){}、function(xxx=""){}
+     * @returns
+     * + true 为空
+     * + false 不为空
+     * @example
+      Utils.isNull({});
+      > true
+     * @example
+      Utils.isNull([]);
+      > true
+     * @example
+      Utils.isNull(" ");
+      > true
+     * @example
+      Utils.isNull(function(){});
+      > true
+     * @example
+      Utils.isNull(()=>{}));
+      > true
+     * @example
+      Utils.isNull("undefined");
+      > true
+     * @example
+      Utils.isNull("null");
+      > true
+     * @example
+      Utils.isNull(" ", false);
+      > true
+     * @example
+      Utils.isNull([1],[]);
+      > false
+     * @example
+      Utils.isNull([],[1]);
+      > false
+     * @example
+      Utils.isNull(false,[123]);
+      > false
+     **/
+	isNull(...args: any[]): boolean;
+	isNull(...args: any[]): boolean {
+		let result = true;
+		let checkList = [...args];
+		for (const objItem of checkList) {
+			let itemResult = false;
+			if (objItem === null || objItem === undefined) {
+				itemResult = true;
+			} else {
+				switch (typeof objItem) {
+					case "object":
+						if (typeof objItem[Symbol.iterator] === "function") {
+							/* 可迭代 */
+							itemResult = objItem.length === 0;
+						} else {
+							itemResult = Object.keys(objItem).length === 0;
+						}
+						break;
+					case "number":
+						itemResult = objItem === 0;
+						break;
+					case "string":
+						itemResult =
+							objItem.trim() === "" ||
+							objItem === "null" ||
+							objItem === "undefined";
+						break;
+					case "boolean":
+						itemResult = !objItem;
+						break;
+					case "function":
+						let funcStr = objItem.toString().replace(/\s/g, "");
+						/* 排除()=>{}、(xxx="")=>{}、function(){}、function(xxx=""){} */
+						itemResult = Boolean(
+							funcStr.match(/^\(.*?\)=>\{\}$|^function.*?\(.*?\)\{\}$/)
+						);
+						break;
+				}
+			}
+			result = result && itemResult;
+		}
+
+		return result;
+	}
+
+	/**
+	 * 判断浏览器主题是否是暗黑|深色模式
+	 */
+	isThemeDark(): boolean;
+	isThemeDark(): boolean {
+		return globalThis.matchMedia("(prefers-color-scheme: dark)").matches;
+	}
+	/**
+	 * 判断元素是否在页面中可见
+	 * @param element 需要检查的元素，可以是普通元素|数组形式的元素|通过querySelectorAll获取的元素数组
+	 * @param inView
+	 * + true 在窗口可视区域
+	 * + false 不在窗口可视区域
+	 * @returns
+	 * + true 可见
+	 * + false 不可见
+	 * @example
+	 * Utils.isVisible(document.documentElement)
+	 * > true
+	 */
+	isVisible(element: HTMLElement[] | NodeList, inView?: boolean): boolean;
+	isVisible(
+		element: HTMLElement[] | NodeList,
+		inView: boolean = false
+	): boolean {
+		let needCheckDomList = [];
+		if (element instanceof Array || element instanceof NodeList) {
+			element = element as HTMLElement[];
+			needCheckDomList = [...element];
+		} else {
+			needCheckDomList = [element];
+		}
+		let result = true;
+		for (const domItem of needCheckDomList) {
+			let domDisplay = window.getComputedStyle(domItem);
+			if (domDisplay.display === "none") {
+				result = false;
+			} else {
+				let domClientRect = domItem.getBoundingClientRect();
+				if (inView) {
+					let viewportWidth =
+						window.innerWidth || document.documentElement.clientWidth;
+					let viewportHeight =
+						window.innerHeight || document.documentElement.clientHeight;
+					result = !(
+						domClientRect.right < 0 ||
+						domClientRect.left > viewportWidth ||
+						domClientRect.bottom < 0 ||
+						domClientRect.top > viewportHeight
+					);
+				} else {
+					result = Boolean(domItem.getClientRects().length);
+				}
+			}
+			if (!result) {
+				/* 有一个不可见就退出循环 */
+				break;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * 判断是否是Via浏览器环境
+	 * @returns
+	 * + true 是Via
+	 * + false 不是Via
+	 * @example
+	 * Utils.isWebView_Via()
+	 * > false
+	 */
+	isWebView_Via(): boolean;
+	isWebView_Via(): boolean {
+		let result = true;
+		let UtilsContext = this;
+		if (typeof (UtilsCore.top.window as any).via === "object") {
+			for (const key in Object.values((UtilsCore.top.window as any).via)) {
+				if (Reflect.has((UtilsCore.top.window as any).via, key)) {
+					let objValueFunc = (UtilsCore.top.window as any).via[key];
+					if (
+						typeof objValueFunc === "function" &&
+						UtilsContext.isNativeFunc(objValueFunc)
+					) {
+						result = true;
+					} else {
+						result = false;
+						break;
+					}
+				}
+			}
+		} else {
+			result = false;
+		}
+		return result;
+	}
+	/**
+	 * 判断是否是X浏览器环境
+	 * @returns
+	 * + true 是X浏览器
+	 * + false 不是X浏览器
+	 * @example
+	 * Utils.isWebView_X()
+	 * > false
+	 */
+	isWebView_X(): boolean;
+	isWebView_X(): boolean {
+		let result = true;
+		let UtilsContext = this;
+		if (typeof (UtilsCore.top.window as any).mbrowser === "object") {
+			for (const key in Object.values((UtilsCore.top.window as any).mbrowser)) {
+				if (Reflect.has((UtilsCore.top.window as any).mbrowser, key)) {
+					let objValueFunc = (UtilsCore.top.window as any).mbrowser[key];
+					if (
+						typeof objValueFunc === "function" &&
+						UtilsContext.isNativeFunc(objValueFunc)
+					) {
+						result = true;
+					} else {
+						result = false;
+						break;
+					}
+				}
+			}
+		} else {
+			result = false;
+		}
+		return result;
+	}
+	/**
+	 * 把对象内的value值全部取出成数组
+	 * @param target 目标对象
+	 * @returns 返回数组
+	 * @example
+	 * Utils.parseObjectToArray({"工具类":"jsonToArray","return","Array"});
+	 * > ['jsonToArray', 'Array']
+	 **/
+	parseObjectToArray(target: AnyObject): any;
+	parseObjectToArray(target: AnyObject): any {
+		if (typeof target !== "object") {
+			throw new Error(
+				"Utils.parseObjectToArray 参数 target 必须为 object 类型"
+			);
+		}
+		let result: any[] = [];
+		Object.keys(target).forEach(function (keyName) {
+			result = result.concat(target[keyName]);
+		});
+		return result;
+	}
+	/**
+     * 监听某个元素键盘按键事件或window全局按键事件
+     * 按下有值的键时触发，按下Ctrl\Alt\Shift\Meta是无值键。按下先触发keydown事件，再触发keypress事件。
+     * @param target 需要监听的对象，可以是全局Window或者某个元素
+     * @param eventName 事件名，默认keypress
+     * @param callback 自己定义的回调事件，参数1为当前的key，参数2为组合按键，数组类型，包含ctrl、shift、alt和meta（win键或mac的cmd键）
+     * @example 
+        Utils.listenKeyboard(window,(keyName,keyValue,otherKey,event)=>{
+            if(keyName === "Enter"){
+                console.log("回车按键的值是："+keyValue)
+            }
+            if(otherKey.indexOf("ctrl") && keyName === "Enter" ){
+                console.log("Ctrl和回车键");
+          }
+        })
+     * @example
+    字母和数字键的键码值(keyCode)
+      按键	键码	按键	键码	按键	键码	按键	键码
+      A	65	J	74	S	83	1	49
+      B	66	K	75	T	84	2	50
+      C	67	L	76	U	85	3	51
+      D	68	M	77	V	86	4	52
+      E	69	N	78	W	87	5	53
+      F	70	O	79	X	88	6	54
+      G	71	P	80	Y	89	7	55
+      H	72	Q	81	Z	90	8	56
+      I	73	R	82	0	48	9	57
+  
+      数字键盘上的键的键码值(keyCode)	
+      功能键键码值(keyCode)
+      按键	键码	按键  	键码	按键	键码	按键	键码
+      0	96	8	104	F1	112	F7	118
+      1	97	9	105	F2	113	F8	119
+      2	98	*	106	F3	114	F9	120
+      3	99	+	107	F4	115	F10	121
+      4	100	Enter	108	F5	116	F11	122
+      5	101	-	109	F6	117	F12	123
+      6	102	.	110	 	 	 	 
+      7	103	/	111	 	 
+      
+      控制键键码值(keyCode)
+      按键		键码	按键		键码	按键		键码	按键		键码
+      BackSpace	8	Esc		27	→		39	-_		189
+      Tab		9	Spacebar	32	↓		40	.>		190
+      Clear		12	Page Up		33	Insert		45	/?		191
+      Enter		13	Page Down	34	Delete		46	`~		192
+      Shift		16	End		35	Num Lock	144	[{		219
+      Control		17	Home		36	;:		186	\|		220
+      Alt		18	←		37	=+		187	]}		221
+      Cape Lock	20	↑		38	,<		188	'"		222
+  
+      多媒体键码值(keyCode)
+      按键		键码
+      音量加		175
+      音量减		174
+      停止		179
+      静音		173
+      浏览器		172
+      邮件		180
+      搜索		170
+      收藏		171
+     **/
+	listenKeyboard(
+		target: Window | Node | HTMLElement | typeof globalThis,
+		eventName: "keyup" | "keypress" | "keydown",
+		callback: (
+			keyName: string,
+			keyValue: string,
+			otherCodeList: string[],
+			event: KeyboardEvent
+		) => void
+	): {
+		removeListen(): void;
+	};
+	listenKeyboard(
+		target: Window | Node | HTMLElement | typeof globalThis,
+		eventName: "keyup" | "keypress" | "keydown" = "keypress",
+		callback: (
+			keyName: string,
+			keyValue: string,
+			otherCodeList: string[],
+			event: KeyboardEvent
+		) => void
+	): {
+		removeListen(): void;
+	} {
+		if (
+			typeof target !== "object" ||
+			(typeof target["addEventListener"] !== "function" &&
+				typeof target["removeEventListener"] !== "function")
+		) {
+			throw new Error(
+				"Utils.listenKeyboard 参数 target 必须为 Window|HTMLElement 类型"
+			);
+		}
+		let keyEvent = function (event: KeyboardEvent) {
+			let keyName = event.key || event.code;
+			let keyValue = event.charCode || event.keyCode || event.which;
+			let otherCodeList = [];
+			if (event.ctrlKey) {
+				otherCodeList.push("ctrl");
+			}
+			if (event.altKey) {
+				otherCodeList.push("alt");
+			}
+			if (event.metaKey) {
+				otherCodeList.push("meta");
+			}
+			if (event.shiftKey) {
+				otherCodeList.push("shift");
+			}
+			if (typeof callback === "function") {
+				callback(keyName, keyValue.toString(), otherCodeList, event);
+			}
+		};
+		target.addEventListener(eventName, keyEvent as any);
+		return {
+			removeListen() {
+				target.removeEventListener(eventName, keyEvent as any);
+			},
+		};
+	}
+	/**
+     * 自动锁对象，用于循环判断运行的函数，在循环外new后使用，注意，如果函数内部存在异步操作，需要使用await
+     * @example
+      let lock = new Utils.LockFunction(()=>{console.log(1)}))
+      lock.run();
+      > 1
+     * @example
+      let lock = new Utils.LockFunction(()=>{console.log(1)}),true) -- 异步操作
+      await lock.run();
+      > 1
+     **/
+	LockFunction: UtilsLockFunction = LockFunction;
+	/**
+     * 日志对象
+     * @param _GM_info_ 油猴管理器的API GM_info，或者是一个对象，如{"script":{name:"Utils.Log"}}
+     * @example
+      let log = new Utils.Log(GM_info);
+      log.info("普通输出");
+      > 普通输出
+  
+      log.success("成功输出");
+      > 成功输出
+  
+      log.error("错误输出");
+      > 错误输出
+      
+      log.warn("警告输出");
+      > 警告输出
+  
+      log.tag = "自定义tag信息";
+      log.info("自定义info的颜色","#e0e0e0");
+      > 自定义info的颜色
+  
+      log.config({
+        successColor: "#31dc02",
+        errorColor: "#e02d2d",
+        infoColor: "black",
+      })
+      log.success("颜色为#31dc02");
+      > 颜色为#31dc02
+     */
+	Log: UtilsLog = Log;
+	/**
+	 * 合并数组内的JSON的值字符串
+	 * @param data 需要合并的数组
+	 * @param handleFunc 处理的函数|JSON的key
+	 * @example
+	 * Utils.mergeArrayToString([{"name":"数组内数据部分字段合并成字符串->"},{"name":"mergeToString"}],(item)=>{return item["name"]});
+	 * > '数组内数据部分字段合并成字符串->mergeToString'
+	 **/
+	mergeArrayToString(data: any[], handleFunc?: (val: any) => any): string;
+	mergeArrayToString(data: any[], handleFunc?: (val: any) => any): string {
+		if (!(data instanceof Array)) {
+			throw new Error("Utils.mergeArrayToString 参数 data 必须为 Array 类型");
+		}
+		let content = "";
+		if (typeof handleFunc === "function") {
+			data.forEach((item) => {
+				content += handleFunc(item);
+			});
+		} else if (typeof handleFunc === "string") {
+			data.forEach((item) => {
+				content += item[handleFunc];
+			});
+		} else {
+			data.forEach((item) => {
+				Object.values(item)
+					.filter((item2) => typeof item2 === "string")
+					.forEach((item3) => {
+						content += item3;
+					});
+			});
+		}
+		return content;
+	}
+	/**
+     * 监听页面元素改变并处理
+     * @param target 需要监听的元素，如果不存在，可以等待它出现
+     * @param observer_config MutationObserver的配置
+     * @example
+      Utils.mutationObserver(document.querySelector("div.xxxx"),{
+        "callback":(mutations, observer)=>{},
+        "config":{childList:true,attributes:true}
+      });
+     * @example
+      Utils.mutationObserver(document.querySelectorAll("div.xxxx"),{
+        "callback":(mutations, observer)=>{},
+        "config":{childList:true,attributes:true}}
+      );
+     * @example
+      Utils.mutationObserver($("div.xxxx"),{
+      "callback":(mutations, observer)=>{},
+      "config":{childList:true,attributes:true}}
+      );
+     **/
+	mutationObserver(
+		target: HTMLElement | Node | NodeList | Document,
+		observer_config: {
+			config?: MutationObserverInit;
+			callback: MutationCallback;
+		}
+	): MutationObserver;
+	mutationObserver(
+		target: HTMLElement | Node | NodeList | Document,
+		observer_config: {
+			config?: MutationObserverInit;
+			callback: MutationCallback;
+		}
+	): MutationObserver {
+		let UtilsContext = this;
+		if (
+			!(target instanceof Node) &&
+			!(target instanceof NodeList) &&
+			!UtilsContext.isJQuery(target)
+		) {
+			throw new Error(
+				"Utils.mutationObserver 参数 target 必须为 Node|NodeList|jQuery类型"
+			);
+		}
+
+		let default_obverser_config = {
+			/* 监听到元素有反馈，需执行的函数 */
+			callback: () => {},
+			config: {
+				/**
+				 * @type {boolean|undefined}
+				 * + true 监听以 target 为根节点的整个子树。包括子树中所有节点的属性，而不仅仅是针对 target
+				 * + false (默认) 不生效
+				 */
+				subtree: void 0,
+				/**
+				 * @type {boolean|undefined}
+				 * + true 监听 target 节点中发生的节点的新增与删除（同时，如果 subtree 为 true，会针对整个子树生效）
+				 * + false (默认) 不生效
+				 */
+				childList: void 0,
+				/**
+				 * @type {boolean|undefined}
+				 * + true 观察所有监听的节点属性值的变化。默认值为 true，当声明了 attributeFilter 或 attributeOldValue
+				 * + false (默认) 不生效
+				 */
+				attributes: void 0,
+				/**
+				 * 一个用于声明哪些属性名会被监听的数组。如果不声明该属性，所有属性的变化都将触发通知
+				 * @type {[...string]|undefined}
+				 */
+				attributeFilter: void 0,
+				/**
+				 * @type {boolean|undefined}
+				 * + true 记录上一次被监听的节点的属性变化；可查阅 MutationObserver 中的 Monitoring attribute values 了解关于观察属性变化和属性值记录的详情
+				 * + false (默认) 不生效
+				 */
+				attributeOldValue: void 0,
+				/**
+				 * @type {boolean|undefined}
+				 * + true 监听声明的 target 节点上所有字符的变化。默认值为 true，如果声明了 characterDataOldValue
+				 * + false (默认) 不生效
+				 */
+				characterData: void 0,
+				/**
+				 * @type {boolean|undefined}
+				 * + true 记录前一个被监听的节点中发生的文本变化
+				 * + false (默认) 不生效
+				 */
+				characterDataOldValue: void 0,
+			},
+		};
+		observer_config = UtilsContext.assign(
+			default_obverser_config,
+			observer_config
+		);
+		let MutationObserver =
+			(UtilsCore.window as any).MutationObserver ||
+			(UtilsCore.window as any).webkitMutationObserver ||
+			(UtilsCore.window as any).MozMutationObserver;
+		/** @type {MutationObserver} */
+		let mutationObserver = new MutationObserver(function (
+			mutations: MutationRecord[],
+			observer: MutationObserver
+		) {
+			observer_config?.callback(mutations, observer);
+		});
+		if (target instanceof Node) {
+			/* 传入的参数是节点元素 */
+			mutationObserver.observe(target, observer_config.config);
+		} else if (target instanceof NodeList) {
+			/* 传入的参数是节点元素数组 */
+			target.forEach((item) => {
+				mutationObserver.observe(item, observer_config.config);
+			});
+		} else if (UtilsContext.isJQuery(target)) {
+			/* 传入的参数是jQuery对象 */
+			(target as any).each((index: any, item: any) => {
+				mutationObserver.observe(item, observer_config.config);
+			});
+		} else {
+			/* 未知 */
+			console.error("Utils.mutationObserver 未知参数", arguments);
+		}
+		return mutationObserver;
+	}
+	/**
+	 * 去除全局window下的Utils，返回控制权
+	 * @example
+	 * let utils = Utils.noConflict();
+	 * > ...
+	 */
+	noConflict = function () {
+		if ((UtilsCore.window as any).Utils) {
+			Reflect.deleteProperty(UtilsCore.window as any, "Utils");
+		}
+		(UtilsCore.window as any).Utils = utils;
+		return utils;
+	};
+	/**
+     * 恢复/释放该对象内的为function，让它无效/有效
+     * @param needReleaseObject 需要操作的对象
+     * @param needReleaseName 需要操作的对象的名字
+     * @param functionNameList （可选）需要释放的方法，默认：全部方法
+     * @param release （可选）
+     * + true (默认) 释放该对象下的某些方法
+     * + false 恢复该对象下的某些方法
+     * @example
+      // 释放该方法
+      Utils.noConflictFunc(console,"console",["log"],true);
+      console.log;
+      > () => {}
+  
+     * @example
+      // 恢复该方法
+      Utils.noConflictFunc(console,"console",["log"],false);
+      console.log;
+      > ƒ log() { [native code] }
+  
+     * @example
+      // 释放所有方法
+      Utils.noConflictFunc(console,"console",[],true);
+      console.debug;
+      > () => {}
+  
+     * @example
+      // 恢复所有方法
+      Utils.noConflictFunc(console,"console",[],false);
+      console.debug;
+      > ƒ log() { [native code] }
+     **/
+	noConflictFunc(
+		needReleaseObject: object,
+		needReleaseName: string,
+		functionNameList?: any[],
+		release?: boolean
+	): void;
+	noConflictFunc(
+		needReleaseObject: object,
+		needReleaseName: string,
+		functionNameList: any[] = [],
+		release: boolean = true
+	): void {
+		let UtilsContext = this;
+		if (typeof needReleaseObject !== "object") {
+			throw new Error(
+				"Utils.noConflictFunc 参数 needReleaseObject 必须为 object 类型"
+			);
+		}
+		if (typeof needReleaseName !== "string") {
+			throw new Error(
+				"Utils.noConflictFunc 参数 needReleaseName 必须为 string 类型"
+			);
+		}
+		if (!Array.isArray(functionNameList)) {
+			throw new Error(
+				"Utils.noConflictFunc 参数 functionNameList 必须为 Array 类型"
+			);
+		}
+		let needReleaseKey = "__" + needReleaseName;
+		/**
+		 * 释放所有
+		 */
+		function releaseAll() {
+			if (typeof (UtilsCore.window as any)[needReleaseKey] !== "undefined") {
+				/* 已存在 */
+				return;
+			}
+			(UtilsCore.window as any)[needReleaseKey] =
+				UtilsContext.deepClone(needReleaseObject);
+			Object.values(needReleaseObject).forEach((value) => {
+				if (typeof value === "function") {
+					(needReleaseObject as any)[value.name] = () => {};
+				}
+			});
+		}
+		/**
+		 * 释放单个
+		 */
+		function releaseOne() {
+			Array.from(functionNameList).forEach((item) => {
+				Object.values(needReleaseObject).forEach((value) => {
+					if (typeof value === "function") {
+						if (
+							typeof (UtilsCore.window as any)[needReleaseKey] === "undefined"
+						) {
+							(UtilsCore.window as any)[needReleaseKey] = {};
+						}
+						if (item === value.name) {
+							(UtilsCore.window as any)[needReleaseKey][value.name] = (
+								needReleaseObject as any
+							)[value.name];
+							(needReleaseObject as any)[value.name] = () => {};
+						}
+					}
+				});
+			});
+		}
+		/**
+		 * 恢复所有
+		 */
+		function recoveryAll() {
+			if (typeof (UtilsCore.window as any)[needReleaseKey] === "undefined") {
+				/* 未存在 */
+				return;
+			}
+			Object.assign(
+				needReleaseObject,
+				(UtilsCore.window as any)[needReleaseKey]
+			);
+			Reflect.deleteProperty(UtilsCore.window as any, "needReleaseKey");
+		}
+
+		/**
+		 * 恢复单个
+		 */
+		function recoveryOne() {
+			if (typeof (UtilsCore.window as any)[needReleaseKey] === "undefined") {
+				/* 未存在 */
+				return;
+			}
+			Array.from(functionNameList).forEach((item) => {
+				if ((UtilsCore.window as any)[needReleaseKey][item]) {
+					(needReleaseObject as any)[item] = (UtilsCore.window as any)[
+						needReleaseKey
+					][item];
+					Reflect.deleteProperty(
+						(UtilsCore.window as any)[needReleaseKey],
+						item
+					);
+					if (
+						Object.keys((UtilsCore.window as any)[needReleaseKey]).length === 0
+					) {
+						Reflect.deleteProperty(window, needReleaseKey);
+					}
+				}
+			});
+		}
+		if (release) {
+			/* 释放 */
+			if (functionNameList.length === 0) {
+				releaseAll();
+			} else {
+				/* 对单个进行操作 */
+				releaseOne();
+			}
+		} else {
+			/* 恢复 */
+			if (functionNameList.length === 0) {
+				recoveryAll();
+			} else {
+				/* 对单个进行操作 */
+				recoveryOne();
+			}
+		}
+	}
+	/**
+	 * base64转blob
+	 * @param dataUri base64的数据
+	 * @returns blob的链接
+	 * @example
+	 * Utils.parseBase64ToBlob("data:image/jpeg;base64,.....");
+	 * > blob://xxxxxxx
+	 **/
+	parseBase64ToBlob(dataUri: string): Blob;
+	parseBase64ToBlob(dataUri: string): Blob {
+		if (typeof dataUri !== "string") {
+			throw new Error(
+				"Utils.parseBase64ToBlob 参数 dataUri 必须为 string 类型"
+			);
+		}
+		let dataUriSplit = dataUri.split(","),
+			dataUriMime = (dataUriSplit[0] as any).match(/:(.*?);/)[1],
+			dataUriBase64Str = atob(dataUriSplit[1]),
+			dataUriLength = dataUriBase64Str.length,
+			u8arr = new Uint8Array(dataUriLength);
+		while (dataUriLength--) {
+			u8arr[dataUriLength] = dataUriBase64Str.charCodeAt(dataUriLength);
+		}
+		return new Blob([u8arr], {
+			type: dataUriMime,
+		});
+	}
+	/**
+	 * base64转File对象
+	 * @param dataUri base64的数据
+	 * @param fileName （可选）文件名，默认：example
+	 * @returns blob的链接
+	 * @example
+	 * Utils.parseBase64ToFile("data:image/jpeg;base64,.....","测试文件");
+	 * > object
+	 **/
+	parseBase64ToFile(dataUri: string, fileName?: string): File;
+	parseBase64ToFile(dataUri: string, fileName = "example") {
+		if (typeof dataUri !== "string") {
+			throw new Error(
+				"Utils.parseBase64ToFile 参数 dataUri 必须为 string 类型"
+			);
+		}
+		if (typeof fileName !== "string") {
+			throw new Error(
+				"Utils.parseBase64ToFile 参数 fileName 必须为 string 类型"
+			);
+		}
+		let dataUriSplit = dataUri.split(","),
+			dataUriMime = (dataUriSplit[0] as any).match(/:(.*?);/)[1],
+			dataUriBase64Str = atob(dataUriSplit[1]),
+			dataUriLength = dataUriBase64Str.length,
+			u8arr = new Uint8Array(dataUriLength);
+		while (dataUriLength--) {
+			u8arr[dataUriLength] = dataUriBase64Str.charCodeAt(dataUriLength);
+		}
+		return new File([u8arr], fileName, {
+			type: dataUriMime,
+		});
+	}
+	/**
+	 * 将正则匹配到的结果取出最后一个值并转换成int格式
+	 * @param matchList 正则匹配的列表
+	 * @param defaultValue 正则匹配的列表为空时，或者正则匹配的列表最后一项不为Int，返回该默认值0
+	 * @example
+	 * Utils.parseInt(["dadaadada123124","123124"],0);
+	 * > 123124
+	 *
+	 * @example
+	 * Utils.parseInt(null,0);
+	 * > 0
+	 * @example
+	 * Utils.parseInt(["aaaaaa"]);
+	 * > 0
+	 *
+	 * @example
+	 * Utils.parseInt(["aaaaaa"],"66");
+	 * > 66
+	 *
+	 * @example
+	 * Utils.parseInt(["aaaaaaa"],"aa");
+	 * > NaN
+	 **/
+	parseInt(matchList?: any[], defaultValue?: number): number;
+	parseInt(matchList: any[] = [], defaultValue = 0): number {
+		if (matchList == null) {
+			return parseInt(defaultValue.toString());
+		}
+		let parseValue = parseInt(matchList[matchList.length - 1]);
+		if (isNaN(parseValue)) {
+			parseValue = parseInt(defaultValue.toString());
+		}
+		return parseValue;
+	}
+	/**
+	 * blob转File对象
+	 * @param blobUrl 需要转换的blob的链接
+	 * @param fileName （可选）转换成的File对象的文件名称，默认：example
+	 * @example
+	 * Utils.parseBlobToFile("blob://xxxxx");
+	 * > object
+	 **/
+	parseBlobToFile(blobUrl: string, fileName?: string): Promise<File | Error>;
+	async parseBlobToFile(
+		blobUrl: string,
+		fileName: string = "example"
+	): Promise<File | Error> {
+		return new Promise((resolve, reject) => {
+			fetch(blobUrl)
+				.then((response) => response.blob())
+				.then((blob) => {
+					const file = new File([blob], fileName, { type: blob.type });
+					resolve(file);
+				})
+				.catch((error) => {
+					console.error("Error:", error);
+					reject(error);
+				});
+		});
+	}
+	/**
+	 * 解析CDATA格式的内容字符串
+	 * @param text 传入CDATA字符串
+	 * @returns 返回解析出的内容
+	 * @example
+	 * let xml = "<root><![CDATA[This is some CDATA content.]]></root>";
+	 * console.log(Utils.parseCDATA(xml));
+	 * > This is some CDATA content.
+	 */
+	parseCDATA(text: string): string;
+	parseCDATA(text: string = ""): string {
+		let result = "";
+		let cdataRegexp = /<\!\[CDATA\[([\s\S]*)\]\]>/;
+		let cdataMatch = cdataRegexp.exec(text.trim());
+		if (cdataMatch && cdataMatch.length > 1) {
+			result = cdataMatch[cdataMatch.length - 1];
+		}
+		return result;
+	}
+	/**
+	 * 【异步函数】File对象转base64
+	 * @param fileObj 需要转换的File对象
+	 * @example
+	 * await Utils.parseFileToBase64(object);
+	 * > 'data:image/jpeg:base64/,xxxxxx'
+	 **/
+	parseFileToBase64(fileObj: File): Promise<string>;
+	async parseFileToBase64(fileObj: File): Promise<string> {
+		let reader = new FileReader();
+		reader.readAsDataURL(fileObj);
+		return new Promise((resolve) => {
+			reader.onload = function (event: any) {
+				resolve(event.target.result as string);
+			};
+		});
+	}
+	/**
+	 * 解析字符串
+	 * @param text 要解析的 DOMString。它必须包含 HTML、xml、xhtml+xml 或 svg 文档。
+	 * @param mimeType （可选）解析成的类型
+	 * + （默认）text/html
+	 * + text/xml
+	 * + application/xml
+	 * + application/xhtml+xml
+	 * + image/svg+xml
+	 * @example
+	 * Utils.parseFromString("<p>123<p>");
+	 * > #document
+	 */
+	parseFromString(
+		text: string,
+		mimeType?:
+			| "text/html"
+			| "text/xml"
+			| "application/xml"
+			| "application/xhtml+xml"
+			| "image/svg+xml"
+	): HTMLElement | XMLDocument | SVGElement;
+	parseFromString(
+		text: string,
+		mimeType:
+			| "text/html"
+			| "text/xml"
+			| "application/xml"
+			| "application/xhtml+xml"
+			| "image/svg+xml" = "text/html"
+	): HTMLElement | XMLDocument | SVGElement {
+		let parser = new DOMParser();
+		return parser.parseFromString(text, mimeType);
+	}
+	/**
+	 * 将字符串进行正则转义
+	 * 例如：^替换$
+	 * 转换：\^替换\$
+	 */
+	parseStringToRegExpString(text: string): string;
+	parseStringToRegExpString(text: string): string {
+		if (typeof text !== "string") {
+			throw new TypeError("string必须是字符串");
+		}
+		let regString = text.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+		return regString;
+	}
+	/**
+	 * 阻止事件传递
+	 * @param element 要进行处理的元素
+	 * @param eventNameList （可选）要阻止的事件名|列表
+	 * @param capture （可选）是否捕获，默认false
+	 * @example
+	 * Utils.preventEvent(document.querySelector("a"),"click")
+	 * @example
+	 * Utils.preventEvent(event);
+	 */
+	preventEvent(event: Event): boolean;
+	/**
+	 * 阻止事件传递
+	 * @param element 要进行处理的元素
+	 * @param eventNameList （可选）要阻止的事件名|列表
+	 * @param capture （可选）是否捕获，默认false
+	 * @example
+	 * Utils.preventEvent(document.querySelector("a"),"click")
+	 * @example
+	 * Utils.preventEvent(event);
+	 */
+	preventEvent(
+		element: HTMLElement,
+		eventNameList?: string | string[],
+		capture?: boolean
+	): boolean;
+	preventEvent(
+		element: HTMLElement | Event,
+		eventNameList: string | string[] = [],
+		capture?: boolean
+	): boolean | undefined {
+		function stopEvent(event: Event) {
+			/* 阻止事件的默认行为发生。例如，当点击一个链接时，浏览器会默认打开链接的URL */
+			event?.preventDefault();
+			/* 停止事件的传播，阻止它继续向更上层的元素冒泡，事件将不会再传播给其他的元素 */
+			event?.stopPropagation();
+			/* 阻止事件传播，并且还能阻止元素上的其他事件处理程序被触发 */
+			event?.stopImmediatePropagation();
+			return false;
+		}
+		if (arguments.length === 1) {
+			/* 直接阻止事件 */
+			return stopEvent(arguments[0]);
+		} else {
+			/* 添加对应的事件来阻止触发 */
+			if (typeof eventNameList === "string") {
+				eventNameList = [eventNameList];
+			}
+			eventNameList.forEach((eventName) => {
+				(element as HTMLElement).addEventListener(eventName, stopEvent, {
+					capture: Boolean(capture),
+				});
+			});
+		}
+	}
+	/**
+     * 在canvas元素节点上绘制进度圆圈
+     * @example
+      let progress = new Utils.Process({canvasNode:document.querySelector("canvas")});
+      progress.draw();
+     * **/
+	Progress: UtilsProgress = Progress;
+	/**
+	 * 劫持Event的isTrust为true，注入时刻，ducument-start
+	 * @param isTrustValue （可选）让isTrusted为true
+	 * @param filter （可选）过滤出需要的事件名，true为需要，false为不需要
+	 * @example
+	 * Utils.registerTrustClickEvent()
+	 */
+	registerTrustClickEvent(
+		isTrustValue?: boolean,
+		filter?: (typeName: string) => boolean
+	): void;
+	registerTrustClickEvent(
+		isTrustValue: boolean = true,
+		filter?: (typeName: string) => boolean
+	): void {
+		function trustEvent(event: Event) {
+			return new Proxy(event, {
+				get: function (target, property) {
+					if (property === "isTrusted") {
+						return isTrustValue;
+					} else {
+						return Reflect.get(target, property);
+					}
+				},
+			});
+		}
+		if (filter == null) {
+			filter = function (typeName) {
+				return typeName === "click";
+			};
+		}
+		const originalListener = EventTarget.prototype.addEventListener;
+		EventTarget.prototype.addEventListener = function (...args) {
+			let type = args[0];
+			let callback = args[1];
+			let options = args[2];
+			if (filter(type)) {
+				if (typeof callback === "function") {
+					args[1] = function (event) {
+						callback.call(this, trustEvent(event));
+					};
+				} else if (
+					typeof callback === "object" &&
+					"handleEvent" in (callback as any)
+				) {
+					let oldHandleEvent = (callback as any)["handleEvent"];
+
+					(args[1] as any)["handleEvent"] = function (event: Event) {
+						if (event == null) {
+							return;
+						}
+						try {
+							/* Proxy对象使用instanceof会报错 */
+							event instanceof Proxy;
+							oldHandleEvent.call(this, trustEvent(event));
+						} catch (error) {
+							// @ts-ignore
+							event["isTrusted"] = isTrustValue;
+						}
+					};
+				}
+			}
+			return originalListener.apply(this, args);
+		};
+	}
+	/**
+	 * 将数字进行正/负转换
+	 * @param num 需要进行转换的数字
+	 */
+	reverseNumber(num: number): number;
+	reverseNumber(num: number): number {
+		let reversedNum = 0;
+		let isNegative = false;
+
+		if (num < 0) {
+			isNegative = true;
+			num = Math.abs(num);
+		}
+
+		while (num > 0) {
+			reversedNum = reversedNum * 10 + (num % 10);
+			num = Math.floor(num / 10);
+		}
+
+		return isNegative ? -reversedNum : reversedNum;
+	}
+	/**
+	 * 将元素上的文本或元素使用光标进行选中
+	 *
+	 * 注意，如果设置startIndex和endIndex，且元素上并无可选则的坐标，那么会报错
+	 * @param element 目标元素
+	 * @param childTextNode 目标元素下的#text元素
+	 * @param startIndex （可选）开始坐标，可为空
+	 * @param endIndex （可选）结束坐标，可为空
+	 */
+	selectElementText(
+		element: HTMLElement | Element | Node,
+		childTextNode: ChildNode,
+		startIndex?: number,
+		endIndex?: number
+	): void;
+	selectElementText(
+		element: HTMLElement | Element | Node,
+		childTextNode: ChildNode,
+		startIndex?: number,
+		endIndex?: number
+	): void {
+		let range = document.createRange();
+		range.selectNodeContents(element);
+		if (childTextNode) {
+			if (childTextNode.nodeType !== Node.TEXT_NODE) {
+				throw new TypeError("childTextNode必须是#text元素");
+			}
+			if (startIndex != null && endIndex != null) {
+				range.setStart(childTextNode, startIndex);
+				range.setEnd(childTextNode, endIndex);
+			}
+		}
+
+		let selection = globalThis.getSelection();
+		if (selection) {
+			selection.removeAllRanges();
+			selection.addRange(range);
+		}
+	}
+	/**
+	 * 复制到剪贴板
+	 * @param data 需要复制到剪贴板的文本
+	 * @param info （可选）默认：text/plain
+	 * @example
+	 * Utils.setClip({1:2});
+	 * > {"1":2}
+	 * @example
+	 * Utils.setClip( ()=>{
+	 *   console.log(1)
+	 * });
+	 * > ()=>{console.log(1)}
+	 * @example
+	 * Utils.setClip("xxxx");
+	 * > xxxx
+	 * @example
+	 * Utils.setClip("xxxx","html");
+	 * > xxxx
+	 * @example
+	 * Utils.setClip("xxxx","text/plain");
+	 * > xxxx
+	 **/
+	setClip(
+		data: any,
+		info?:
+			| {
+					type: string;
+					mimetype: string;
+			  }
+			| string
+	): Promise<boolean>;
+	setClip(
+		data: any,
+		info?:
+			| {
+					type: string;
+					mimetype: string;
+			  }
+			| string
+	): Promise<boolean> {
+		if (typeof data === "object") {
+			if (data instanceof Element) {
+				data = data.outerHTML;
+			} else {
+				data = JSON.stringify(data);
+			}
+		} else if (typeof data !== "string") {
+			data = data.toString();
+		}
+		let textType = typeof info === "object" ? info.type : (info as string);
+		if (textType.includes("html")) {
+			textType = "text/html";
+		} else {
+			textType = "text/plain";
+		}
+		class UtilsClipboard {
+			#resolve;
+			#copyData;
+			#copyDataType;
+			constructor(
+				resolve: (value: boolean | PromiseLike<boolean>) => void,
+				copyData: any,
+				copyDataType: string
+			) {
+				this.#resolve = resolve;
+				this.#copyData = copyData;
+				this.#copyDataType = copyDataType;
+			}
+			async init() {
+				let copyStatus = false;
+				let requestPermissionStatus = await this.requestClipboardPermission();
+				if (
+					this.hasClipboard() &&
+					(this.hasClipboardWrite() || this.hasClipboardWriteText())
+				) {
+					try {
+						copyStatus = await this.copyDataByClipboard();
+					} catch (error) {
+						console.error("复制失败，使用第二种方式，error👉", error);
+						copyStatus = this.copyTextByTextArea();
+					}
+				} else {
+					copyStatus = this.copyTextByTextArea();
+				}
+				this.#resolve(copyStatus);
+				this.destroy();
+			}
+			destroy() {
+				// @ts-ignore
+				this.#resolve = null;
+				// @ts-ignore
+				this.#copyData = null;
+				// @ts-ignore
+				this.#copyDataType = null;
+			}
+			isText() {
+				return this.#copyDataType.includes("text");
+			}
+			hasClipboard() {
+				return navigator?.clipboard != null;
+			}
+			hasClipboardWrite() {
+				return navigator?.clipboard?.write != null;
+			}
+			hasClipboardWriteText() {
+				return navigator?.clipboard?.writeText != null;
+			}
+			/**
+			 * 使用textarea和document.execCommand("copy")来复制文字
+			 */
+			copyTextByTextArea() {
+				try {
+					let copyElement = document.createElement("textarea");
+					copyElement.value = this.#copyData;
+					copyElement.setAttribute("type", "text");
+					copyElement.setAttribute("style", "opacity:0;position:absolute;");
+					copyElement.setAttribute("readonly", "readonly");
+					document.body.appendChild(copyElement);
+					copyElement.select();
+					document.execCommand("copy");
+					document.body.removeChild(copyElement);
+					return true;
+				} catch (error) {
+					console.error("复制失败，error👉", error);
+					return false;
+				}
+			}
+			/**
+			 * 申请剪贴板权限
+			 * @returns {Promise<boolean>}
+			 */
+			requestClipboardPermission() {
+				return new Promise((resolve, reject) => {
+					if (navigator.permissions && navigator.permissions.query) {
+						navigator.permissions
+							.query({
+								// @ts-ignore
+								name: "clipboard-write",
+							})
+							.then((permissionStatus) => {
+								resolve(true);
+							})
+							.catch(
+								/** @param {TypeError} error */
+								(error) => {
+									console.error([
+										"申请剪贴板权限失败，尝试直接写入👉",
+										error.message ?? error.name ?? error.stack,
+									]);
+									resolve(false);
+								}
+							);
+					} else {
+						resolve(false);
+					}
+				});
+			}
+			/**
+			 * 使用clipboard直接写入数据到剪贴板
+			 */
+			copyDataByClipboard(): Promise<boolean> {
+				return new Promise((resolve, reject) => {
+					if (this.isText()) {
+						/* 只复制文字 */
+						navigator.clipboard
+							.writeText(this.#copyData)
+							.then(() => {
+								resolve(true);
+							})
+							.catch((error) => {
+								reject(error);
+							});
+					} else {
+						/* 可复制对象 */
+						let textBlob = new Blob([this.#copyData], {
+							type: this.#copyDataType,
+						});
+						navigator.clipboard
+							.write([
+								new ClipboardItem({
+									[this.#copyDataType]: textBlob,
+								}),
+							])
+							.then(() => {
+								resolve(true);
+							})
+							.catch((error) => {
+								reject(error);
+							});
+					}
+				});
+			}
+		}
+		return new Promise((resolve) => {
+			const utilsClipboard = new UtilsClipboard(resolve, data, textType);
+			if (document.hasFocus()) {
+				utilsClipboard.init();
+			} else {
+				window.addEventListener(
+					"focus",
+					() => {
+						utilsClipboard.init();
+					},
+					{ once: true }
+				);
+			}
+		});
+	}
+	/**
+	 * 【异步函数】等待N秒执行函数
+	 * @param callback 待执行的函数(字符串)
+	 * @param delayTime （可选）延时时间(ms)，默认：0
+	 * @example
+	 * await Utils.setTimeout(()=>{}, 2500);
+	 * > ƒ tryCatchObj() {}
+	 * @example
+	 * await Utils.setTimeout("()=>{console.log(12345)}", 2500);
+	 * > ƒ tryCatchObj() {}
+	 **/
+	setTimeout(callback: (() => void) | string, delayTime?: number): Promise<any>;
+	setTimeout(
+		callback: (() => void) | string,
+		delayTime: number = 0
+	): Promise<any> {
+		let UtilsContext = this;
+		if (typeof callback !== "function" && typeof callback !== "string") {
+			throw new TypeError(
+				"Utils.setTimeout 参数 callback 必须为 function|string 类型"
+			);
+		}
+		if (typeof delayTime !== "number") {
+			throw new TypeError("Utils.setTimeout 参数 delayTime 必须为 number 类型");
+		}
+		return new Promise((resolve) => {
+			setTimeout(() => {
+				resolve(UtilsContext.tryCatch().run(callback));
+			}, delayTime);
+		});
+	}
+	/**
+	 * 【异步函数】延迟xxx毫秒
+	 * @param delayTime （可选）延时时间(ms)，默认：0
+	 * @example
+	 * await Utils.sleep(2500)
+	 **/
+	sleep(delayTime?: number): Promise<void>;
+	sleep(delayTime: number = 0): Promise<void> {
+		if (typeof delayTime !== "number") {
+			throw new Error("Utils.sleep 参数 delayTime 必须为 number 类型");
+		}
+		return new Promise((resolve) => {
+			setTimeout(() => {
+				resolve(void 0);
+			}, delayTime);
+		});
+	}
+	/**
+	 * 向右拖动滑块
+	 * @param selector 选择器|元素
+	 * @param offsetX （可选）水平拖动长度，默认：window.innerWidth
+	 * @example
+	 * Utils.dragSlider("#xxxx");
+	 * @example
+	 * Utils.dragSlider("#xxxx",100);
+	 */
+	dragSlider(selector: string | Element | Node, offsetX?: number): void;
+	dragSlider(
+		selector: string | Element | Node,
+		offsetX: number = UtilsCore.window.innerWidth
+	): void {
+		function initMouseEvent(
+			eventName: string,
+			offSetX: number,
+			offSetY: number
+		) {
+			let win = unsafeWindow || window;
+			let mouseEvent = document.createEvent("MouseEvents");
+			mouseEvent.initMouseEvent(
+				eventName,
+				true,
+				true,
+				win,
+				0,
+				offSetX,
+				offSetY,
+				offSetX,
+				offSetY,
+				false,
+				false,
+				false,
+				false,
+				0,
+				null
+			);
+			return mouseEvent;
+		}
+		let sliderElement =
+			typeof selector === "string"
+				? document.querySelector(selector)
+				: selector;
+		if (
+			!(sliderElement instanceof Node) ||
+			!(sliderElement instanceof Element)
+		) {
+			throw new Error("Utils.dragSlider 参数selector 必须为Node/Element类型");
+		}
+		let rect = sliderElement.getBoundingClientRect(),
+			x0 = rect.x || rect.left,
+			y0 = rect.y || rect.top,
+			x1 = x0 + offsetX,
+			y1 = y0;
+		sliderElement.dispatchEvent(initMouseEvent("mousedown", x0, y0));
+		sliderElement.dispatchEvent(initMouseEvent("mousemove", x1, y1));
+		sliderElement.dispatchEvent(initMouseEvent("mouseleave", x1, y1));
+		sliderElement.dispatchEvent(initMouseEvent("mouseout", x1, y1));
+	}
+	/**
+	 * 使目标元素进入全屏
+	 * @param element （可选）目标元素，默认：document.documentElement
+	 * @param options （可选）配置，一般不用
+	 * @example
+	 * Utils.enterFullScreen();
+	 */
+	enterFullScreen(element: HTMLElement, options?: FullscreenOptions): void;
+	enterFullScreen(
+		element: HTMLElement = UtilsCore.document.documentElement,
+		options?: FullscreenOptions
+	): void {
+		try {
+			if (element.requestFullscreen) {
+				element.requestFullscreen(options);
+			} else if ((element as any).webkitRequestFullScreen) {
+				(element as any).webkitRequestFullScreen();
+			} else if ((element as any).mozRequestFullScreen) {
+				(element as any).mozRequestFullScreen();
+			} else if ((element as any).msRequestFullscreen) {
+				(element as any).msRequestFullscreen();
+			} else {
+				throw new TypeError("该浏览器不支持全屏API");
+			}
+		} catch (err) {
+			console.error(err);
+		}
+	}
+	/**
+	 * 使浏览器退出全屏
+	 * @param element （可选）目标元素，默认：document.documentElement
+	 * @example
+	 * Utils.exitFullScreen();
+	 */
+	exitFullScreen(element?: HTMLElement): Promise<void>;
+	exitFullScreen(
+		element: HTMLElement = document.documentElement
+	): Promise<void> {
+		if (UtilsCore.document.exitFullscreen) {
+			return UtilsCore.document.exitFullscreen();
+		} else if ((UtilsCore.document as any).msExitFullscreen) {
+			return (UtilsCore.document as any).msExitFullscreen();
+		} else if ((UtilsCore.document as any).mozCancelFullScreen) {
+			return (UtilsCore.document as any).mozCancelFullScreen();
+		} else if ((UtilsCore.document as any).webkitCancelFullScreen) {
+			return (UtilsCore.document as any).webkitCancelFullScreen();
+		} else {
+			return new Promise((resolve, reject) => {
+				reject(new TypeError("该浏览器不支持全屏API"));
+			});
+		}
+	}
+	/**
+	 * 数组按照内部某个值的大小比对排序，如[{"time":"2022-1-1"},{"time":"2022-2-2"}]
+	 * @param data 数据|获取数据的方法
+	 * @param getPropertyValueFunc 数组内部项的某个属性的值的方法，参数为这个项
+	 * @param sortByDesc （可选）排序方式
+	 * + true (默认)倒序(值最大排第一个，如:6、5、4、3...)
+	 * + false 升序(值最小排第一个，如:1、2、3、4...)
+	 * @returns 返回比较排序完成的数组
+	 * @example
+	 * Utils.sortListByProperty([{"time":"2022-1-1"},{"time":"2022-2-2"}],(item)=>{return item["time"]})
+	 * > [{time: '2022-2-2'},{time: '2022-1-1'}]
+	 * @example
+	 * Utils.sortListByProperty([{"time":"2022-1-1"},{"time":"2022-2-2"}],(item)=>{return item["time"]},false)
+	 * > [{time: '2022-1-1'},{time: '2022-2-2'}]
+	 **/
+	sortListByProperty<T extends any[] | NodeList>(
+		data: T,
+		getPropertyValueFunc: string | ((value: T) => any),
+		sortByDesc?: boolean
+	): T;
+	sortListByProperty<T extends any[] | NodeList>(
+		data: T,
+		getPropertyValueFunc: string | ((value: T) => any),
+		sortByDesc: boolean = true
+	): T {
+		let UtilsContext = this;
+		if (
+			typeof getPropertyValueFunc !== "function" &&
+			typeof getPropertyValueFunc !== "string"
+		) {
+			throw new Error(
+				"Utils.sortListByProperty 参数 getPropertyValueFunc 必须为 function|string 类型"
+			);
+		}
+		if (typeof sortByDesc !== "boolean") {
+			throw new Error(
+				"Utils.sortListByProperty 参数 sortByDesc 必须为 boolean 类型"
+			);
+		}
+		let getObjValue = function (obj: any) {
+			return typeof getPropertyValueFunc === "string"
+				? obj[getPropertyValueFunc]
+				: getPropertyValueFunc(obj);
+		};
+		/**
+		 * 排序方法
+		 * @param {any} after_obj
+		 * @param {any} before_obj
+		 * @returns
+		 */
+		let sortFunc = function (after_obj: any, before_obj: any) {
+			let beforeValue = getObjValue(before_obj); /*  前 */
+			let afterValue = getObjValue(after_obj); /* 后 */
+			if (sortByDesc) {
+				if (afterValue > beforeValue) {
+					return -1;
+				} else if (afterValue < beforeValue) {
+					return 1;
+				} else {
+					return 0;
+				}
+			} else {
+				if (afterValue < beforeValue) {
+					return -1;
+				} else if (afterValue > beforeValue) {
+					return 1;
+				} else {
+					return 0;
+				}
+			}
+		};
+		/**
+		 * 排序元素方法
+		 * @param  nodeList 元素列表
+		 * @param getNodeListFunc 获取元素列表的函数
+		 */
+		let sortNodeFunc = function (
+			nodeList: NodeListOf<HTMLElement>,
+			getNodeListFunc: () => NodeListOf<HTMLElement>
+		) {
+			let nodeListLength = nodeList.length;
+			for (let i = 0; i < nodeListLength - 1; i++) {
+				for (let j = 0; j < nodeListLength - 1 - i; j++) {
+					let beforeNode = nodeList[j];
+					let afterNode = nodeList[j + 1];
+					let beforeValue = getObjValue(beforeNode); /*  前 */
+					let afterValue = getObjValue(afterNode); /* 后 */
+					if (
+						(sortByDesc == true && beforeValue < afterValue) ||
+						(sortByDesc == false && beforeValue > afterValue)
+					) {
+						/* 升序/降序 */
+						/* 相邻元素两两对比 */
+						let temp = beforeNode.nextElementSibling;
+						afterNode.after(beforeNode);
+						if (temp == null) {
+							/* 如果为空，那么是最后一个元素，使用append */
+							(temp as any).parentNode.appendChild(afterNode);
+						} else {
+							/* 不为空，使用before */
+							temp.before(afterNode);
+						}
+						nodeList = getNodeListFunc();
+					}
+				}
+			}
+		};
+		let result = data;
+		let getDataFunc = null;
+		if (data instanceof Function) {
+			getDataFunc = data;
+			data = (data as any)();
+		}
+		if (Array.isArray(data)) {
+			data.sort(sortFunc);
+		} else if (data instanceof NodeList || UtilsContext.isJQuery(data)) {
+			sortNodeFunc(data as any, getDataFunc as any);
+			result = (getDataFunc as any)();
+		} else {
+			throw new Error(
+				"Utils.sortListByProperty 参数 data 必须为 Array|NodeList|jQuery 类型"
+			);
+		}
+		return result;
+	}
+	/**
+	 * 字符串转正则，用于把字符串中不规范的字符进行转义
+	 * @param targetString 需要进行转换的字符串
+	 * @param flags 正则标志
+	 */
+	stringToRegular(
+		targetString: string | RegExp,
+		flags?: "g" | "i" | "m" | "u" | "y" | string
+	): RegExp;
+	stringToRegular(
+		targetString: string | RegExp,
+		flags: "g" | "i" | "m" | "u" | "y" | string = "ig"
+	): RegExp {
+		let reg;
+		// @ts-ignore
+		flags = flags.toLowerCase();
+		if (typeof targetString === "string") {
+			reg = new RegExp(
+				targetString.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"),
+				flags
+			);
+		} else if ((targetString as any) instanceof RegExp) {
+			reg = targetString;
+		} else {
+			throw new Error(
+				"Utils.stringToRegular 参数targetString必须是string|Regexp类型"
+			);
+		}
+		return reg;
+	}
+	/**
+	 * 字符串首字母转大写
+	 * @param targetString 目标字符串
+	 * @param otherStrToLowerCase （可选）剩余部分字符串转小写，默认false
+	 */
+	stringTitleToUpperCase(
+		targetString: string,
+		otherStrToLowerCase?: boolean
+	): string;
+	stringTitleToUpperCase(
+		targetString: string,
+		otherStrToLowerCase: boolean = false
+	): string {
+		let newTargetString = targetString.slice(0, 1).toUpperCase();
+		if (otherStrToLowerCase) {
+			newTargetString = newTargetString + targetString.slice(1).toLowerCase();
+		} else {
+			newTargetString = newTargetString + targetString.slice(1);
+		}
+		return newTargetString;
+	}
+	/**
+	 * 判断目标字符串是否是以xxx开始
+	 *
+	 * 如果searchString是字符串数组，那么判断的结果则是字符串数组中的任意字符匹配到返回true
+	 * @param target 目标字符串
+	 * @param searchString 需要搜索的字符串
+	 * @param position （可选）目标字符串的判断起点，要求≥0，默认为0
+	 */
+	startsWith(
+		target: string,
+		searchString: string | RegExp | string[],
+		position?: number
+	): boolean;
+	startsWith(
+		target: string,
+		searchString: string | RegExp | string[],
+		position: number = 0
+	): boolean {
+		let UtilsContext = this;
+		if (position > target.length) {
+			/* 超出目标字符串的长度 */
+			return false;
+		}
+		if (position !== 0) {
+			target = target.slice(position, target.length);
+		}
+		let searchStringRegexp = searchString;
+		if (typeof searchString === "string") {
+			searchStringRegexp = new RegExp(`^${searchString}`);
+		} else if (Array.isArray(searchString)) {
+			let flag = false;
+			for (const searcStr of searchString) {
+				if (!UtilsContext.startsWith(target, searcStr, position)) {
+					flag = true;
+					break;
+				}
+			}
+			return flag;
+		}
+		return Boolean(target.match(searchStringRegexp as RegExp));
+	}
+	/**
+	 * 字符串首字母转小写
+	 * @param targetString 目标字符串
+	 * @param otherStrToLowerCase （可选）剩余部分字符串转大写，默认false
+	 */
+	stringTitleToLowerCase(
+		targetString: string,
+		otherStrToUpperCase?: boolean
+	): string;
+	stringTitleToLowerCase(
+		targetString: string,
+		otherStrToUpperCase: boolean = false
+	): string {
+		let newTargetString = targetString.slice(0, 1).toLowerCase();
+		if (otherStrToUpperCase) {
+			newTargetString = newTargetString + targetString.slice(1).toUpperCase();
+		} else {
+			newTargetString = newTargetString + targetString.slice(1);
+		}
+		return newTargetString;
+	}
+	/**
+	 * 字符串转Object对象，类似'{"test":""}' => {"test":""}
+	 * @param data
+	 * @param errorCallBack （可选）错误回调
+	 * @example
+	 * Utils.toJSON("{123:123}")
+	 * > {123:123}
+	 */
+	toJSON<T extends AnyObject>(
+		data: string | null,
+		errorCallBack?: (error: Error) => void
+	): T;
+	toJSON<T extends AnyObject>(
+		data: string | null,
+		errorCallBack?: (error: Error) => void
+	): T {
+		let UtilsContext = this;
+		let result: AnyObject = {};
+		if (typeof data === "object") {
+			return data as any;
+		}
+		UtilsContext.tryCatch()
+			.config({ log: false })
+			.error((error: Error) => {
+				UtilsContext.tryCatch()
+					.error(() => {
+						try {
+							result = (UtilsCore.window as any).eval("(" + data + ")");
+						} catch (error2: any) {
+							if (typeof errorCallBack === "function") {
+								errorCallBack(error2);
+							}
+						}
+					})
+					.run(() => {
+						if (
+							data &&
+							/^[\],:{}\s]*$/.test(
+								data
+									.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
+									.replace(
+										/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
+										"]"
+									)
+									.replace(/(?:^|:|,)(?:\s*\[)+/g, "")
+							)
+						) {
+							result = new Function("return " + data)();
+						} else {
+							if (typeof errorCallBack === "function") {
+								errorCallBack(new Error("target is not a JSON"));
+							}
+						}
+					});
+			})
+			.run(() => {
+				data = (data as string).trim();
+				result = JSON.parse(data);
+			});
+		return result as any;
+	}
+	/**
+	 * 对象转为UrlSearchParams格式的字符串
+	 * @param obj 目标对象，可以是对象组成的数组
+	 */
+	toSearchParamsStr(obj: object | object[]): string;
+	toSearchParamsStr(obj: object | object[]): string {
+		let UtilsContext = this;
+		let searhParamsStr = "";
+		if (Array.isArray(obj)) {
+			obj.forEach((item) => {
+				if (searhParamsStr === "") {
+					searhParamsStr += UtilsContext.toSearchParamsStr(item);
+				} else {
+					searhParamsStr += "&" + UtilsContext.toSearchParamsStr(item);
+				}
+			});
+		} else {
+			searhParamsStr = new URLSearchParams(Object.entries(obj)).toString();
+		}
+		return searhParamsStr;
+	}
+	/**
+	 * 提供一个封装了 try-catch 的函数，可以执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
+	 * @returns 返回一个对象，其中包含 error 和 run 两个方法。
+	 * @example
+	 * Utils.tryCatch().error().run(()=>{console.log(1)});
+	 * > 1
+	 * @example
+	 * Utils.tryCatch().config({log:true}).error((error)=>{console.log(error)}).run(()=>{throw new Error('测试错误')});
+	 * > ()=>{throw new Error('测试错误')}出现错误
+	 */
+	tryCatch = TryCatch;
+	/**
+	 * 数组去重，去除重复的值
+	 * @param uniqueArrayData 需要去重的数组
+	 * @param compareArrayData 用来比较的数组
+	 * @param compareFun 数组比较方法，如果值相同，去除该数据
+	 * @returns 返回去重完毕的数组
+	 * @example
+	 * Utils.uniqueArray([1,2,3],[1,2],(item,item2)=>{return item===item2 ? true:false});
+	 * > [3]
+	 *
+	 * @example
+	 * Utils.uniqueArray([1,2,3],[1,2]);
+	 * > [3]
+	 *
+	 * @example
+	 * Utils.uniqueArray([{"key":1,"value":2},{"key":2}],[{"key":1}],(item,item2)=>{return item["key"] === item2["key"] ? true:false});
+	 * > [{"key": 2}]
+	 **/
+	uniqueArray<T extends any, TT extends any>(
+		uniqueArrayData?: T[],
+		compareArrayData?: TT[],
+		compareFun?: (item1: T, item2: TT) => boolean
+	): any[];
+	uniqueArray<T extends any, TT extends any>(
+		uniqueArrayData: T[] = [],
+		compareArrayData: TT[] = [],
+		compareFun: (item1: T, item2: TT) => boolean = (item, item2) => {
+			// @ts-ignore
+			return item === item2;
+		}
+	): any[] {
+		return Array.from(uniqueArrayData).filter(
+			(item) =>
+				!Array.from(compareArrayData).some(function (item2) {
+					return compareFun(item, item2);
+				})
+		);
+	}
+	/**
+	 * 等待函数数组全部执行完毕，注意，每个函数的顺序不是同步
+	 * @param data 需要遍历的数组
+	 * @param handleFunc 对该数组进行操作的函数，该函数的参数为数组格式的参数,[数组下标，数组项]
+	 * @example
+	 * await Utils.waitArrayLoopToEnd([callback,callback,callback],xxxcallback);
+	 **/
+	waitArrayLoopToEnd(
+		data: any[] | HTMLElement[],
+		handleFunc: Function
+	): Promise<void[]>;
+	waitArrayLoopToEnd(
+		data: any[] | HTMLElement[],
+		handleFunc: Function
+	): Promise<void[]> {
+		let UtilsContext = this;
+		if (typeof handleFunc !== "function" && typeof handleFunc !== "string") {
+			throw new Error(
+				"Utils.waitArrayLoopToEnd 参数 handleDataFunction 必须为 function|string 类型"
+			);
+		}
+		return Promise.all(
+			Array.from(data).map(async (item, index) => {
+				await UtilsContext.tryCatch(index, item).run(handleFunc);
+			})
+		);
+	}
+	/**
+	 * 等待指定元素出现，支持多个selector
+	 * @param nodeSelectors 一个或多个节点选择器，必须为字符串类型
+	 * @example
+	 * Utils.waitNode("div.xxx").then( element =>{
+	 *  console.log(element); // div.xxx => HTMLElement
+	 * })
+	 * @example
+	 * Utils.waitNode("div.xxx","a.xxx").then( (elementList)=>{
+	 *  console.log(elementList[0]); // div.xxx => HTMLElement
+	 *  console.log(elementList[1]); // a.xxx => HTMLElement
+	 * })
+	 */
+	waitNode<T extends HTMLElement>(nodeSelector: string | [string]): Promise<T>;
+	/**
+	 * 等待指定元素出现，支持多个selector
+	 * @param nodeSelectors 一个或多个节点选择器，必须为字符串类型
+	 * @example
+	 * Utils.waitNode("div.xxx").then( element =>{
+	 *  console.log(element); // div.xxx => HTMLElement
+	 * })
+	 * @example
+	 * Utils.waitNode("div.xxx","a.xxx").then( (elementList)=>{
+	 *  console.log(elementList[0]); // div.xxx => HTMLElement
+	 *  console.log(elementList[1]); // a.xxx => HTMLElement
+	 * })
+	 */
+	waitNode<T extends HTMLElement>(...nodeSelectors: string[]): Promise<T[]>;
+	/**
+	 * 等待指定元素出现，支持多个selector
+	 * @param nodeSelectors 一个或多个节点选择器，必须为字符串类型
+	 * @example
+	 * Utils.waitNode("div.xxx").then( element =>{
+	 *  console.log(element); // div.xxx => HTMLElement
+	 * })
+	 * @example
+	 * Utils.waitNode("div.xxx","a.xxx").then( (elementList)=>{
+	 *  console.log(elementList[0]); // div.xxx => HTMLElement
+	 *  console.log(elementList[1]); // a.xxx => HTMLElement
+	 * })
+	 */
+	waitNode<T extends HTMLElement>(...nodeSelectors: string[]): Promise<T | T[]>;
+	async waitNode<T extends HTMLElement>(
+		...nodeSelectors: string | string[] | any
+	): Promise<T | T[]> {
+		/* 检查每个参数是否为字符串类型 */
+		for (let nodeSelector of nodeSelectors) {
+			if (typeof nodeSelector !== "string") {
+				throw new Error("Utils.waitNode 参数必须都是 string 类型");
+			}
+		}
+		let UtilsContext = this;
+		return new Promise((resolve) => {
+			/* 防止触发第二次回调 */
+			let isReturn = false;
+
+			/**
+			 * 检查所有选择器是否匹配到节点
+			 * @param observer
+			 */
+			let checkNodes = (observer?: MutationObserver) => {
+				let isFind = true;
+				let selectNodeArray: HTMLElement[] = [];
+				for (let selector of nodeSelectors) {
+					let element = document.querySelector(selector) as HTMLElement | null;
+					if (!element) {
+						/* 没找到，直接退出循环 */
+						isFind = false;
+						break;
+					}
+					selectNodeArray.push(element);
+				}
+				if (isFind) {
+					isReturn = true;
+					observer?.disconnect();
+					/* 如果只有一个选择器，那么返回数组中存储的第一个 */
+					if (selectNodeArray.length === 1) {
+						resolve(selectNodeArray[0] as any);
+					} else {
+						resolve(selectNodeArray as any);
+					}
+				}
+			};
+
+			/* 在函数开始时检查节点是否已经存在 */
+			checkNodes();
+
+			/* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
+			UtilsContext.mutationObserver(document.documentElement, {
+				config: { subtree: true, childList: true, attributes: true },
+				callback: (mutations, observer) => {
+					if (isReturn) {
+						return;
+					}
+					checkNodes(observer);
+				},
+			});
+		});
+	}
+	/**
+	 * 在规定时间内，等待任意元素出现，支持多个selector，如果未出现，则关闭监听
+	 * @param nodeSelectorsList 一个或多个节点选择器，必须为字符串类型
+	 * @param maxTime （可选）xx毫秒(ms)后关闭监听，默认：0(ms)
+	 * @example
+	 * Utils.waitNodeWithInterval("a.xxx",30000).then(element=>{
+	 *   console.log(element);
+	 * })
+	 * @example
+	 * Utils.waitNodeWithInterval(["div.xxx","a.xxx"],30000).then(elementList=>{
+	 *   console.log(elementList[0]); // div.xxx => HTMLElement
+	 *   console.log(elementList[1]); // a.xxx => HTMLElement
+	 * })
+	 */
+	waitNodeWithInterval<T extends HTMLElement>(
+		nodeSelectorsList?: string[] | string,
+		maxTime?: number
+	): Promise<T | T[]>;
+	waitNodeWithInterval<T extends HTMLElement>(
+		nodeSelectorsList: string[] | string = [],
+		maxTime: number = 0
+	): Promise<T | T[]> {
+		let UtilsContext = this;
+		let nodeSelectors: string[] = [];
+		/* 检查每个参数是否为字符串类型 */
+		if (Array.isArray(nodeSelectorsList)) {
+			for (let nodeSelector of nodeSelectorsList) {
+				if (typeof nodeSelector !== "string") {
+					throw new Error(
+						"Utils.waitNodeWithInterval 参数nodeSelectorsList必须为 string[] 类型"
+					);
+				}
+			}
+			nodeSelectors = nodeSelectorsList;
+		} else {
+			nodeSelectors.push(nodeSelectorsList);
+		}
+
+		return new Promise((resolve, reject) => {
+			/* 防止触发第二次回调 */
+			let isReturn = false;
+
+			/* 检查所有选择器是否匹配到节点 */
+			let checkNodes = (observer?: MutationObserver) => {
+				let isFind = true;
+				let selectNodeArray = [];
+				for (let selector of nodeSelectors) {
+					let element = document.querySelector(selector);
+					if (!element) {
+						/* 没找到，直接退出循环 */
+						isFind = false;
+						break;
+					}
+					selectNodeArray.push(element);
+				}
+				if (isFind) {
+					isReturn = true;
+					observer?.disconnect();
+					/* 如果只有一个选择器，那么返回数组中存储的第一个 */
+					if (selectNodeArray.length === 1) {
+						resolve(selectNodeArray[0] as any);
+					} else {
+						resolve(selectNodeArray as any);
+					}
+				}
+			};
+
+			/* 在函数开始时检查节点是否已经存在 */
+			checkNodes();
+
+			/* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
+			let mutationObserver = UtilsContext.mutationObserver(
+				document.documentElement,
+				{
+					config: { subtree: true, childList: true, attributes: true },
+					callback: (mutations, observer) => {
+						if (isReturn) {
+							return;
+						}
+						checkNodes(observer);
+					},
+				}
+			);
+			setTimeout(() => {
+				mutationObserver.disconnect();
+				reject();
+			}, maxTime);
+		});
+	}
+
+	/**
+	 * 等待任意元素出现，支持多个selector
+	 * @param nodeSelectors 一个或多个节点选择器，必须为字符串类型
+	 * @example
+	 * Utils.waitAnyNode("div.xxx","a.xxx").then( element =>{
+	 *   console.log(element); // a.xxx => HTMLElement
+	 * })
+	 */
+	waitAnyNode<T extends HTMLElement>(...nodeSelectors: any[]): Promise<T>;
+	waitAnyNode<T extends HTMLElement>(...nodeSelectors: any[]): Promise<T> {
+		let UtilsContext = this;
+		/* 检查每个参数是否为字符串类型 */
+		for (let nodeSelector of nodeSelectors) {
+			if (typeof nodeSelector !== "string") {
+				throw new Error("Utils.waitNode 参数必须为 ...string 类型");
+			}
+		}
+
+		return new Promise((resolve) => {
+			/* 防止触发第二次回调 */
+			let isReturn = false;
+
+			/* 检查所有选择器是否存在任意匹配到元素 */
+			let checkNodes = (observer?: MutationObserver) => {
+				let selectNode = null;
+				for (let selector of nodeSelectors) {
+					selectNode = document.querySelector(selector);
+					if (selectNode) {
+						/* 找到，退出循环 */
+						break;
+					}
+				}
+				if (selectNode) {
+					isReturn = true;
+					observer?.disconnect();
+					resolve(selectNode);
+				}
+			};
+
+			/* 在函数开始时检查节点是否已经存在 */
+			checkNodes();
+
+			/* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
+			UtilsContext.mutationObserver(document.documentElement, {
+				config: { subtree: true, childList: true, attributes: true },
+				callback: (mutations, observer) => {
+					if (isReturn) {
+						return;
+					}
+					checkNodes(observer);
+				},
+			});
+		});
+	}
+	/**
+	 * 等待指定元素出现
+	 * @param nodeSelectors
+	 * @returns 当nodeSelectors为数组多个时，
+	 * 返回如：[ NodeList, NodeList ]，
+	 * 当nodeSelectors为单个时，
+	 * 返回如：NodeList。
+	 * NodeList元素与页面存在强绑定，当已获取该NodeList，但是页面中却删除了，该元素在NodeList中会被自动删除
+	 * @example
+	 * Utils.waitNodeList("div.xxx").then( nodeList =>{
+	 *  console.log(nodeList) // div.xxx => NodeList
+	 * })
+	 * @example
+	 * Utils.waitNodeList("div.xxx","a.xxx").then( nodeListArray =>{
+	 *  console.log(nodeListArray[0]) // div.xxx => NodeList
+	 *  console.log(nodeListArray[1]) // a.xxx => NodeList
+	 * })
+	 */
+	waitNodeList<T extends HTMLElement>(nodeSelector: string): Promise<T>;
+	/**
+	 * 等待指定元素出现，支持多个selector
+	 * @param nodeSelectors
+	 * @returns 当nodeSelectors为数组多个时，
+	 * 返回如：[ NodeList, NodeList ]，
+	 * 当nodeSelectors为单个时，
+	 * 返回如：NodeList。
+	 * NodeList元素与页面存在强绑定，当已获取该NodeList，但是页面中却删除了，该元素在NodeList中会被自动删除
+	 * @example
+	 * Utils.waitNodeList("div.xxx").then( nodeList =>{
+	 *  console.log(nodeList) // div.xxx => NodeList
+	 * })
+	 * @example
+	 * Utils.waitNodeList("div.xxx","a.xxx").then( nodeListArray =>{
+	 *  console.log(nodeListArray[0]) // div.xxx => NodeList
+	 *  console.log(nodeListArray[1]) // a.xxx => NodeList
+	 * })
+	 */
+	waitNodeList<T extends HTMLElement>(
+		...nodeSelectors: string[]
+	): Promise<NodeListOf<T>[]>;
+	waitNodeList<T extends HTMLElement>(
+		...nodeSelectors: string[]
+	): Promise<NodeListOf<T>[]> {
+		let UtilsContext = this;
+		/* 检查每个参数是否为字符串类型 */
+		for (let nodeSelector of nodeSelectors) {
+			if (typeof nodeSelector !== "string") {
+				throw new Error("Utils.waitNode 参数必须为 ...string 类型");
+			}
+		}
+
+		return new Promise((resolve) => {
+			/* 防止触发第二次回调 */
+			let isReturn = false;
+
+			/* 检查所有选择器是否匹配到节点 */
+			let checkNodes = (observer?: MutationObserver) => {
+				let isFind = true;
+				let selectNodes = [];
+				for (let selector of nodeSelectors) {
+					let nodeList = document.querySelectorAll(selector);
+					if (nodeList.length === 0) {
+						/* 没找到，直接退出循环 */
+						isFind = false;
+						break;
+					}
+					selectNodes.push(nodeList);
+				}
+				if (isFind) {
+					isReturn = true;
+					observer?.disconnect();
+					/* 如果只有一个选择器，那么返回第一个 */
+					if (selectNodes.length === 1) {
+						resolve(selectNodes[0] as any);
+					} else {
+						resolve(selectNodes as any);
+					}
+				}
+			};
+
+			/* 在函数开始时检查节点是否已经存在 */
+			checkNodes();
+
+			/* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
+			UtilsContext.mutationObserver(document.documentElement, {
+				config: { subtree: true, childList: true, attributes: true },
+				callback: (mutations, observer) => {
+					if (isReturn) {
+						return;
+					}
+					checkNodes(observer);
+				},
+			});
+		});
+	}
+	/**
+	 * 等待任意元素出现，支持多个selector
+	 * @param nodeSelectors
+	 * @returns 返回NodeList
+	 * NodeList元素与页面存在强绑定，当已获取该NodeList，但是页面中却删除了，该元素在NodeList中会被自动删除
+	 * @example
+	 * Utils.waitAnyNodeList("div.xxx").then( nodeList =>{
+	 *  console.log(nodeList) // div.xxx => NodeList
+	 * })
+	 * @example
+	 * Utils.waitAnyNodeList("div.xxx","a.xxx").then( nodeList =>{
+	 *  console.log(nodeList) // a.xxx => NodeList
+	 * })
+	 */
+	waitAnyNodeList<T extends HTMLElement>(
+		...nodeSelectors: string[]
+	): Promise<NodeListOf<T>[]>;
+	waitAnyNodeList<T extends HTMLElement>(
+		...nodeSelectors: string[]
+	): Promise<NodeListOf<T>[]> {
+		let UtilsContext = this;
+		/* 检查每个参数是否为字符串类型 */
+		for (let nodeSelector of nodeSelectors) {
+			if (typeof nodeSelector !== "string") {
+				throw new Error("Utils.waitNode 参数必须为 ...string 类型");
+			}
+		}
+
+		return new Promise((resolve) => {
+			/* 防止触发第二次回调 */
+			let isReturn = false;
+
+			/* 检查所有选择器是否匹配到节点 */
+			let checkNodes = (observer?: MutationObserver) => {
+				let selectNodes = [];
+				for (let selector of nodeSelectors) {
+					selectNodes = document.querySelectorAll(selector) as any;
+					if (selectNodes.length) {
+						/* 找到，退出循环 */
+						break;
+					}
+				}
+				if (selectNodes.length) {
+					isReturn = true;
+					observer?.disconnect();
+					resolve(selectNodes);
+				}
+			};
+
+			/* 在函数开始时检查节点是否已经存在 */
+			checkNodes();
+
+			/* 监听 DOM 的变化，直到至少有一个节点被匹配到 */
+			UtilsContext.mutationObserver(document.documentElement, {
+				config: { subtree: true, childList: true, attributes: true },
+				callback: (mutations, observer) => {
+					if (isReturn) {
+						return;
+					}
+					checkNodes(observer);
+				},
+			});
+		});
+	}
+	/**
+	 * 等待对象上的属性出现
+	 * @param checkObj 检查的对象
+	 * @param checkPropertyName 检查的对象的属性名
+	 * @example
+	 * await Utils.waitProperty(window,"test");
+	 * console.log("test success set");
+	 *
+	 * window.test = 1;
+	 * > "test success set"
+	 *
+	 */
+	waitProperty<T extends any>(
+		checkObj: AnyObject | (() => AnyObject),
+		checkPropertyName: string
+	): Promise<T>;
+	waitProperty<T extends any>(
+		checkObj: AnyObject | (() => AnyObject),
+		checkPropertyName: string
+	): Promise<T> {
+		return new Promise((resolve) => {
+			let obj = checkObj;
+			if (typeof checkObj === "function") {
+				obj = checkObj();
+			}
+			if (Reflect.has(obj, checkPropertyName)) {
+				resolve((obj as any)[checkPropertyName]);
+			} else {
+				Object.defineProperty(obj, checkPropertyName, {
+					set: function (value) {
+						try {
+							resolve(value);
+						} catch (error) {
+							console.error("Error setting property:", error);
+						}
+					},
+				});
+			}
+		});
+	}
+	/**
+	 * 在规定时间内等待对象上的属性出现
+	 * @param checkObj 检查的对象
+	 * @param checkPropertyName 检查的对象的属性名
+	 * @param intervalTimer （可选）检查间隔时间（ms），默认250ms
+	 * @param maxTime （可选）限制在多长时间内，默认-1(不限制时间)
+	 * @example
+	 * await Utils.waitPropertyByInterval(window,"test");
+	 * console.log("test success set");
+	 */
+	waitPropertyByInterval<T extends any>(
+		checkObj: AnyObject | (() => AnyObject),
+		checkPropertyName: string | ((obj: any) => boolean),
+		intervalTimer?: number,
+		maxTime?: number
+	): Promise<T>;
+	waitPropertyByInterval<T extends any>(
+		checkObj: AnyObject | (() => AnyObject),
+		checkPropertyName: string | ((obj: any) => boolean),
+		intervalTimer: number = 250,
+		maxTime: number = -1
+	): Promise<T> {
+		if (checkObj == null) {
+			throw new TypeError("checkObj 不能为空对象 ");
+		}
+		let isResolve = false;
+		return new Promise((resolve, reject) => {
+			let interval = setInterval(() => {
+				let obj = checkObj;
+				if (typeof checkObj === "function") {
+					obj = checkObj();
+				}
+				if (
+					(typeof checkPropertyName === "function" && checkPropertyName(obj)) ||
+					Reflect.has(obj, checkPropertyName as string)
+				) {
+					isResolve = true;
+					clearInterval(interval);
+					resolve((obj as any)[checkPropertyName as string]);
+				}
+			}, intervalTimer);
+			if (maxTime !== -1) {
+				setTimeout(() => {
+					if (!isResolve) {
+						clearInterval(interval);
+						reject();
+					}
+				}, maxTime);
+			}
+		});
+	}
+	/**
+	 * 在规定时间内等待元素上的__vue__属性或者__vue__属性上的某个值出现出现
+	 * @param element 目标元素
+	 * @param propertyName （可选）vue上的属性名或者传递一个获取属性的方法返回boolean
+	 * @param timer （可选）间隔时间（ms），默认：250(ms)
+	 * @param maxTime（可选） 限制在多长时间内，默认：-1(不限制时间)
+	 * @param vueName （可选）vue挂载的属性名，默认：__vue__
+	 * @example
+	 * await Utils.waitVueByInterval(
+	 * function(){
+	 *    return document.querySelector("a.xx")
+	 * },
+	 * function(__vue__){
+	 *    return Boolean(__vue__.xxx == null);
+	 * },
+	 * 250,
+	 * 10000,
+	 * "__vue__"
+	 * )
+	 */
+	waitVueByInterval(
+		element: HTMLElement | (() => HTMLElement),
+		propertyName: string | ((__vue__: any) => boolean),
+		timer?: number,
+		maxTime?: number,
+		vueName?: "__vue__" | string
+	): Promise<boolean>;
+	async waitVueByInterval(
+		element: HTMLElement | (() => HTMLElement),
+		propertyName: string | ((__vue__: any) => boolean),
+		timer = 250,
+		maxTime = -1,
+		vueName = "__vue__"
+	) {
+		if (element == null) {
+			throw new Error("Utils.waitVueByInterval 参数element 不能为空");
+		}
+		let flag = false;
+		let UtilsContext = this;
+		try {
+			await UtilsContext.waitPropertyByInterval(
+				element,
+				function (targetElement) {
+					if (targetElement == null) {
+						return false;
+					}
+					if (!(vueName in targetElement)) {
+						return false;
+					}
+					if (propertyName == null) {
+						return true;
+					}
+					let vueObject = targetElement[vueName];
+					if (typeof propertyName === "string") {
+						if (propertyName in vueObject) {
+							flag = true;
+							return true;
+						}
+					} else {
+						/* Function */
+						if (propertyName(vueObject)) {
+							flag = true;
+							return true;
+						}
+					}
+					return false;
+				},
+				timer,
+				maxTime
+			);
+		} catch (error) {
+			return flag;
+		}
+		return flag;
+	}
+	/**
+	 * 观察对象的set、get
+	 * @param target 观察的对象
+	 * @param propertyName 观察的对象的属性名
+	 * @param getCallBack （可选）触发get的回调，可以自定义返回特定值
+	 * @param setCallBack （可选）触发set的回调，参数为将要设置的value
+	 * @example
+	 * Utils.watchObject(window,"test",()=>{return 111;},(value)=>{console.log("test出现，值是",value)});
+	 *
+	 * window.test = 1;
+	 * > test出现，值是 1
+	 * console.log(window.test);
+	 * > 111;
+	 */
+	watchObject(
+		target: AnyObject,
+		propertyName: string,
+		getCallBack: (value: any) => void,
+		setCallBack: (value: any) => void
+	): void;
+	watchObject(
+		target: AnyObject,
+		propertyName: string,
+		getCallBack: (value: any) => void,
+		setCallBack: (value: any) => void
+	): void {
+		if (
+			typeof getCallBack !== "function" &&
+			typeof setCallBack !== "function"
+		) {
+			return;
+		}
+
+		if (typeof getCallBack === "function") {
+			Object.defineProperty(target, propertyName, {
+				get() {
+					if (typeof getCallBack === "function") {
+						return getCallBack(target[propertyName]);
+					} else {
+						return target[propertyName];
+					}
+				},
+			});
+		} else if (typeof setCallBack === "function") {
+			Object.defineProperty(target, propertyName, {
+				set(value) {
+					if (typeof setCallBack === "function") {
+						setCallBack(value);
+					}
+				},
+			});
+		} else {
+			Object.defineProperty(target, propertyName, {
+				get() {
+					if (typeof getCallBack === "function") {
+						return (getCallBack as any)(target[propertyName]);
+					} else {
+						return target[propertyName];
+					}
+				},
+				set(value) {
+					if (typeof setCallBack === "function") {
+						(setCallBack as any)(value);
+					}
+				},
+			});
+		}
+	}
+}
+
+let utils = new Utils();
+
+export { utils as Utils };