☰

DOMUtils

使用js重新对jQuery的部分函数进行了仿写

当前为 2024-12-03 提交的版本，查看 最新版本。

此脚本不应直接安装，它是供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.cn-greasyfork.org/scripts/465772/1495575/DOMUtils.js 

  1. (function (global, factory) {
  2.     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  3.     typeof define === 'function' && define.amd ? define(factory) :
  4.     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.DOMUtils = factory());
  5. })(this, (function () { 'use strict';
  6.  
  7.     class WindowApi {
  8.         /** 默认的配置 */
  9.         defaultApi = {
  10.             document: document,
  11.             window: window,
  12.             globalThis: globalThis,
  13.             self: self,
  14.             top: top,
  15.         };
  16.         /** 使用的配置 */
  17.         api;
  18.         constructor(option) {
  19.             if (option) {
  20.                 if (option.globalThis == null) {
  21.                     option.globalThis = option.window;
  22.                 }
  23.                 if (option.self == null) {
  24.                     option.self = option.window;
  25.                 }
  26.             }
  27.             if (!option) {
  28.                 option = Object.assign({}, this.defaultApi);
  29.             }
  30.             // @ts-ignore
  31.             this.api = Object.assign({}, option);
  32.         }
  33.         get document() {
  34.             return this.api.document;
  35.         }
  36.         get window() {
  37.             return this.api.window;
  38.         }
  39.         get globalThis() {
  40.             return this.api.globalThis;
  41.         }
  42.         get self() {
  43.             return this.api.self;
  44.         }
  45.         get top() {
  46.             return this.api.top;
  47.         }
  48.     }
  49.  
  50.     /** 通用工具类 */
  51.     const DOMUtilsCommonUtils = {
  52.         windowApi: new WindowApi({
  53.             document: document,
  54.             window: window,
  55.             top: top,
  56.         }),
  57.         /**
  58.          * 判断元素是否已显示或已连接
  59.          * @param element
  60.          */
  61.         isShow(element) {
  62.             return Boolean(element.getClientRects().length);
  63.         },
  64.         /**
  65.          * 用于显示元素并获取它的高度宽度等其它属性
  66.          * @param element
  67.          */
  68.         showElement(element) {
  69.             let dupNode = element.cloneNode(true);
  70.             dupNode.setAttribute("style", "visibility: hidden !important;display:block !important;");
  71.             this.windowApi.document.documentElement.appendChild(dupNode);
  72.             return {
  73.                 /**
  74.                  * 恢复修改的style
  75.                  */
  76.                 recovery() {
  77.                     dupNode.remove();
  78.                 },
  79.             };
  80.         },
  81.         /**
  82.          * 获取元素上的Float格式的属性px
  83.          * @param element
  84.          * @param styleName style名
  85.          */
  86.         getStyleValue(element, styleName) {
  87.             let view = null;
  88.             let styles = null;
  89.             if (element instanceof CSSStyleDeclaration) {
  90.                 /* 直接就获取了style属性 */
  91.                 styles = element;
  92.             }
  93.             else {
  94.                 view = element.ownerDocument.defaultView;
  95.                 if (!view || !view.opener) {
  96.                     view = window;
  97.                 }
  98.                 styles = view.getComputedStyle(element);
  99.             }
  100.             let value = parseFloat(styles[styleName]);
  101.             if (isNaN(value)) {
  102.                 return 0;
  103.             }
  104.             else {
  105.                 return value;
  106.             }
  107.         },
  108.         /**
  109.          * 判断是否是window，例如window、self、globalThis
  110.          * @param target
  111.          */
  112.         isWin(target) {
  113.             if (typeof target !== "object") {
  114.                 return false;
  115.             }
  116.             if (target instanceof Node) {
  117.                 return false;
  118.             }
  119.             if (target === globalThis) {
  120.                 return true;
  121.             }
  122.             if (target === window) {
  123.                 return true;
  124.             }
  125.             if (target === self) {
  126.                 return true;
  127.             }
  128.             if (target === globalThis) {
  129.                 return true;
  130.             }
  131.             if (target === window) {
  132.                 return true;
  133.             }
  134.             if (target === self) {
  135.                 return true;
  136.             }
  137.             if (typeof unsafeWindow !== "undefined" && target === unsafeWindow) {
  138.                 return true;
  139.             }
  140.             if (target?.Math?.toString() !== "[object Math]") {
  141.                 return false;
  142.             }
  143.             return true;
  144.         },
  145.         /**
  146.          * 删除对象上的属性
  147.          * @param target
  148.          * @param propName
  149.          */
  150.         delete(target, propName) {
  151.             if (typeof Reflect === "object" && Reflect.deleteProperty) {
  152.                 Reflect.deleteProperty(target, propName);
  153.             }
  154.             else {
  155.                 delete target[propName];
  156.             }
  157.         },
  158.     };
  159.  
  160.     /* 数据 */
  161.     const DOMUtilsData = {
  162.         /** .on添加在元素存储的事件 */
  163.         SymbolEvents: Symbol("events_" + (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1)),
  164.     };
  165.  
  166.     const OriginPrototype = {
  167.         Object: {
  168.             defineProperty: Object.defineProperty,
  169.         },
  170.     };
  171.  
  172.     class DOMUtilsEvent {
  173.         windowApi;
  174.         constructor(windowApiOption) {
  175.             this.windowApi = new WindowApi(windowApiOption);
  176.         }
  177.         on(element, eventType, selector, callback, option) {
  178.             /**
  179.              * 获取option配置
  180.              * @param args
  181.              * @param startIndex
  182.              * @param option
  183.              */
  184.             function getOption(args, startIndex, option) {
  185.                 if (typeof args[startIndex] === "boolean") {
  186.                     option.capture = args[startIndex];
  187.                     if (typeof args[startIndex + 1] === "boolean") {
  188.                         option.once = args[startIndex + 1];
  189.                     }
  190.                     if (typeof args[startIndex + 2] === "boolean") {
  191.                         option.passive = args[startIndex + 2];
  192.                     }
  193.                 }
  194.                 else if (typeof args[startIndex] === "object" &&
  195.                     ("capture" in args[startIndex] ||
  196.                         "once" in args[startIndex] ||
  197.                         "passive" in args[startIndex])) {
  198.                     option.capture = args[startIndex].capture;
  199.                     option.once = args[startIndex].once;
  200.                     option.passive = args[startIndex].passive;
  201.                 }
  202.                 return option;
  203.             }
  204.             let DOMUtilsContext = this;
  205.             let args = arguments;
  206.             if (typeof element === "string") {
  207.                 element = DOMUtilsContext.selectorAll(element);
  208.             }
  209.             if (element == null) {
  210.                 return;
  211.             }
  212.             let elementList = [];
  213.             if (element instanceof NodeList || Array.isArray(element)) {
  214.                 element = element;
  215.                 elementList = [...element];
  216.             }
  217.             else {
  218.                 elementList.push(element);
  219.             }
  220.             // 事件名
  221.             let eventTypeList = [];
  222.             if (Array.isArray(eventType)) {
  223.                 eventTypeList = eventTypeList.concat(eventType);
  224.             }
  225.             else if (typeof eventType === "string") {
  226.                 eventTypeList = eventTypeList.concat(eventType.split(" "));
  227.             }
  228.             // 子元素选择器
  229.             let selectorList = [];
  230.             if (Array.isArray(selector)) {
  231.                 selectorList = selectorList.concat(selector);
  232.             }
  233.             else if (typeof selector === "string") {
  234.                 selectorList.push(selector);
  235.             }
  236.             // 事件回调
  237.             let _callback_ = callback;
  238.             // 事件配置
  239.             let _option_ = {
  240.                 capture: false,
  241.                 once: false,
  242.                 passive: false,
  243.             };
  244.             if (typeof selector === "function") {
  245.                 /* 这是为没有selector的情况 */
  246.                 _callback_ = selector;
  247.                 _option_ = getOption(args, 3, _option_);
  248.             }
  249.             else {
  250.                 /* 这是存在selector的情况 */
  251.                 _option_ = getOption(args, 4, _option_);
  252.             }
  253.             /**
  254.              * 如果是once，那么删除该监听和元素上的事件和监听
  255.              */
  256.             function checkOptionOnceToRemoveEventListener() {
  257.                 if (_option_.once) {
  258.                     DOMUtilsContext.off(element, eventType, selector, callback, option);
  259.                 }
  260.             }
  261.             elementList.forEach((elementItem) => {
  262.                 /**
  263.                  * 事件回调
  264.                  * @param event
  265.                  */
  266.                 function domUtilsEventCallBack(event) {
  267.                     let target = event.target;
  268.                     if (selectorList.length) {
  269.                         /* 存在自定义子元素选择器 */
  270.                         let totalParent = DOMUtilsCommonUtils.isWin(elementItem)
  271.                             ? DOMUtilsContext.windowApi.document.documentElement
  272.                             : elementItem;
  273.                         for (let index = 0; index < selectorList.length; index++) {
  274.                             const selectorItem = selectorList[index];
  275.                             if (target.matches(selectorItem)) {
  276.                                 /* 当前目标可以被selector所匹配到 */
  277.                                 _callback_.call(target, event);
  278.                                 checkOptionOnceToRemoveEventListener();
  279.                                 break;
  280.                             }
  281.                             else if (target.closest(selectorItem) &&
  282.                                 totalParent.contains(target.closest(selectorItem))) {
  283.                                 /* 在上层与主元素之间寻找可以被selector所匹配到的 */
  284.                                 let closestElement = target.closest(selectorItem);
  285.                                 /* event的target值不能直接修改 */
  286.                                 OriginPrototype.Object.defineProperty(event, "target", {
  287.                                     get() {
  288.                                         return closestElement;
  289.                                     },
  290.                                 });
  291.                                 _callback_.call(closestElement, event);
  292.                                 checkOptionOnceToRemoveEventListener();
  293.                                 break;
  294.                             }
  295.                         }
  296.                     }
  297.                     else {
  298.                         _callback_.call(elementItem, event);
  299.                         checkOptionOnceToRemoveEventListener();
  300.                     }
  301.                 }
  302.                 /* 遍历事件名设置元素事件 */
  303.                 eventTypeList.forEach((eventName) => {
  304.                     elementItem.addEventListener(eventName, domUtilsEventCallBack, _option_);
  305.                     /* 获取对象上的事件 */
  306.                     let elementEvents = elementItem[DOMUtilsData.SymbolEvents] || {};
  307.                     /* 初始化对象上的xx事件 */
  308.                     elementEvents[eventName] = elementEvents[eventName] || [];
  309.                     elementEvents[eventName].push({
  310.                         selector: selectorList,
  311.                         option: _option_,
  312.                         callback: domUtilsEventCallBack,
  313.                         originCallBack: _callback_,
  314.                     });
  315.                     /* 覆盖事件 */
  316.                     // @ts-ignore
  317.                     elementItem[DOMUtilsData.SymbolEvents] = elementEvents;
  318.                 });
  319.             });
  320.         }
  321.         off(element, eventType, selector, callback, option, filter) {
  322.             /**
  323.              * 获取option配置
  324.              * @param args1
  325.              * @param startIndex
  326.              * @param option
  327.              */
  328.             function getOption(args1, startIndex, option) {
  329.                 if (typeof args1[startIndex] === "boolean") {
  330.                     option.capture = args1[startIndex];
  331.                 }
  332.                 else if (typeof args1[startIndex] === "object" &&
  333.                     "capture" in args1[startIndex]) {
  334.                     option.capture = args1[startIndex].capture;
  335.                 }
  336.                 return option;
  337.             }
  338.             let DOMUtilsContext = this;
  339.             let args = arguments;
  340.             if (typeof element === "string") {
  341.                 element = DOMUtilsContext.selectorAll(element);
  342.             }
  343.             if (element == null) {
  344.                 return;
  345.             }
  346.             let elementList = [];
  347.             if (element instanceof NodeList || Array.isArray(element)) {
  348.                 element = element;
  349.                 elementList = [...element];
  350.             }
  351.             else {
  352.                 elementList.push(element);
  353.             }
  354.             let eventTypeList = [];
  355.             if (Array.isArray(eventType)) {
  356.                 eventTypeList = eventTypeList.concat(eventType);
  357.             }
  358.             else if (typeof eventType === "string") {
  359.                 eventTypeList = eventTypeList.concat(eventType.split(" "));
  360.             }
  361.             // 子元素选择器
  362.             let selectorList = [];
  363.             if (Array.isArray(selector)) {
  364.                 selectorList = selectorList.concat(selector);
  365.             }
  366.             else if (typeof selector === "string") {
  367.                 selectorList.push(selector);
  368.             }
  369.             /**
  370.              * 事件的回调函数
  371.              */
  372.             let _callback_ = callback;
  373.             /**
  374.              * 事件的配置
  375.              */
  376.             let _option_ = {
  377.                 capture: false,
  378.             };
  379.             if (typeof selector === "function") {
  380.                 /* 这是为没有selector的情况 */
  381.                 _callback_ = selector;
  382.                 _option_ = getOption(args, 3, _option_);
  383.             }
  384.             else {
  385.                 _option_ = getOption(args, 4, _option_);
  386.             }
  387.             elementList.forEach((elementItem) => {
  388.                 /* 获取对象上的事件 */
  389.                 // @ts-ignore
  390.                 let elementEvents = elementItem[DOMUtilsData.SymbolEvents] || {};
  391.                 eventTypeList.forEach((eventName) => {
  392.                     let handlers = elementEvents[eventName] || [];
  393.                     if (typeof filter === "function") {
  394.                         handlers = handlers.filter(filter);
  395.                     }
  396.                     for (let index = 0; index < handlers.length; index++) {
  397.                         let handler = handlers[index];
  398.                         let flag = false;
  399.                         if (!selectorList.length) {
  400.                             // selectorList是空的，默认移除
  401.                             flag = true;
  402.                         }
  403.                         else {
  404.                             if (Array.isArray(handler.selector) &&
  405.                                 JSON.stringify(handler.selector) === JSON.stringify(selectorList)) {
  406.                                 // 元素上的selectorList不为空且和传入的相同
  407.                                 flag = true;
  408.                             }
  409.                         }
  410.                         if (!_callback_ ||
  411.                             handler.callback === _callback_ ||
  412.                             handler.originCallBack === _callback_) {
  413.                             /* callback不为空，且callback相同 */
  414.                             flag = true;
  415.                         }
  416.                         if (flag) {
  417.                             elementItem.removeEventListener(eventName, handler.callback, _option_);
  418.                             handlers.splice(index--, 1);
  419.                         }
  420.                     }
  421.                     if (handlers.length === 0) {
  422.                         /* 如果没有任意的handler，那么删除该属性 */
  423.                         DOMUtilsCommonUtils.delete(elementEvents, eventType);
  424.                     }
  425.                 });
  426.                 // @ts-ignore
  427.                 elementItem[DOMUtilsData.SymbolEvents] = elementEvents;
  428.             });
  429.         }
  430.         /**
  431.          * 取消绑定所有的事件
  432.          * @param element 需要取消绑定的元素|元素数组
  433.          * @param eventType （可选）需要取消监听的事件
  434.          */
  435.         offAll(element, eventType) {
  436.             let DOMUtilsContext = this;
  437.             if (typeof element === "string") {
  438.                 element = DOMUtilsContext.selectorAll(element);
  439.             }
  440.             if (element == null) {
  441.                 return;
  442.             }
  443.             let elementList = [];
  444.             if (element instanceof NodeList || Array.isArray(element)) {
  445.                 elementList = [...element];
  446.             }
  447.             else {
  448.                 elementList.push(element);
  449.             }
  450.             let eventTypeList = [];
  451.             if (Array.isArray(eventType)) {
  452.                 eventTypeList = eventTypeList.concat(eventType);
  453.             }
  454.             else if (typeof eventType === "string") {
  455.                 eventTypeList = eventTypeList.concat(eventType.split(" "));
  456.             }
  457.             elementList.forEach((elementItem) => {
  458.                 Object.getOwnPropertySymbols(elementItem).forEach((symbolEvents) => {
  459.                     if (!symbolEvents.toString().startsWith("Symbol(events_")) {
  460.                         return;
  461.                     }
  462.                     let elementEvents = elementItem[symbolEvents] || {};
  463.                     let iterEventNameList = eventTypeList.length
  464.                         ? eventTypeList
  465.                         : Object.keys(elementEvents);
  466.                     iterEventNameList.forEach((eventName) => {
  467.                         let handlers = elementEvents[eventName];
  468.                         if (!handlers) {
  469.                             return;
  470.                         }
  471.                         for (const handler of handlers) {
  472.                             elementItem.removeEventListener(eventName, handler.callback, {
  473.                                 capture: handler["option"]["capture"],
  474.                             });
  475.                         }
  476.                         // @ts-ignore
  477.                         DOMUtilsCommonUtils.delete(elementItem[symbolEvents], eventName);
  478.                     });
  479.                 });
  480.             });
  481.         }
  482.         /**
  483.          * 等待文档加载完成后执行指定的函数
  484.          * @param callback 需要执行的函数
  485.          * @example
  486.          * DOMUtils.ready(function(){
  487.          *   console.log("文档加载完毕")
  488.          * })
  489.          */
  490.         ready(callback) {
  491.             if (typeof callback !== "function") {
  492.                 return;
  493.             }
  494.             let DOMUtilsContext = this;
  495.             /**
  496.              * 检测文档是否加载完毕
  497.              */
  498.             function checkDOMReadyState() {
  499.                 try {
  500.                     if (DOMUtilsContext.windowApi.document.readyState === "complete" ||
  501.                         (DOMUtilsContext.windowApi.document.readyState !== "loading" &&
  502.                             !DOMUtilsContext.windowApi.document.documentElement
  503.                                 .doScroll)) {
  504.                         return true;
  505.                     }
  506.                     else {
  507.                         return false;
  508.                     }
  509.                 }
  510.                 catch (error) {
  511.                     return false;
  512.                 }
  513.             }
  514.             /**
  515.              * 成功加载完毕后触发的回调函数
  516.              */
  517.             function completed() {
  518.                 removeDomReadyListener();
  519.                 callback();
  520.             }
  521.             let targetList = [
  522.                 {
  523.                     target: DOMUtilsContext.windowApi.document,
  524.                     eventType: "DOMContentLoaded",
  525.                     callback: completed,
  526.                 },
  527.                 {
  528.                     target: DOMUtilsContext.windowApi.window,
  529.                     eventType: "load",
  530.                     callback: completed,
  531.                 },
  532.             ];
  533.             /**
  534.              * 添加监听
  535.              */
  536.             function addDomReadyListener() {
  537.                 for (let index = 0; index < targetList.length; index++) {
  538.                     let item = targetList[index];
  539.                     item.target.addEventListener(item.eventType, item.callback);
  540.                 }
  541.             }
  542.             /**
  543.              * 移除监听
  544.              */
  545.             function removeDomReadyListener() {
  546.                 for (let index = 0; index < targetList.length; index++) {
  547.                     let item = targetList[index];
  548.                     item.target.removeEventListener(item.eventType, item.callback);
  549.                 }
  550.             }
  551.             if (checkDOMReadyState()) {
  552.                 /* 检查document状态 */
  553.                 setTimeout(callback);
  554.             }
  555.             else {
  556.                 /* 添加监听 */
  557.                 addDomReadyListener();
  558.             }
  559.         }
  560.         /**
  561.          * 主动触发事件
  562.          * @param element 需要触发的元素|元素数组|window
  563.          * @param eventType 需要触发的事件
  564.          * @param details 赋予触发的Event的额外属性，如果是Event类型，那么将自动代替默认new的Event对象
  565.          * @param useDispatchToTriggerEvent 是否使用dispatchEvent来触发事件,默认true
  566.          * @example
  567.          * // 触发元素a.xx的click事件
  568.          * DOMUtils.trigger(document.querySelector("a.xx"),"click")
  569.          * DOMUtils.trigger("a.xx","click")
  570.          * // 触发元素a.xx的click、tap、hover事件
  571.          * DOMUtils.trigger(document.querySelector("a.xx"),"click tap hover")
  572.          * DOMUtils.trigger("a.xx",["click","tap","hover"])
  573.          */
  574.         trigger(element, eventType, details, useDispatchToTriggerEvent = true) {
  575.             let DOMUtilsContext = this;
  576.             if (typeof element === "string") {
  577.                 element = DOMUtilsContext.selectorAll(element);
  578.             }
  579.             if (element == null) {
  580.                 return;
  581.             }
  582.             let elementList = [];
  583.             if (element instanceof NodeList || Array.isArray(element)) {
  584.                 element = element;
  585.                 elementList = [...element];
  586.             }
  587.             else {
  588.                 elementList = [element];
  589.             }
  590.             let eventTypeList = [];
  591.             if (Array.isArray(eventType)) {
  592.                 eventTypeList = eventType;
  593.             }
  594.             else if (typeof eventType === "string") {
  595.                 eventTypeList = eventType.split(" ");
  596.             }
  597.             elementList.forEach((elementItem) => {
  598.                 /* 获取对象上的事件 */
  599.                 let events = elementItem[DOMUtilsData.SymbolEvents] || {};
  600.                 eventTypeList.forEach((_eventType_) => {
  601.                     let event = null;
  602.                     if (details && details instanceof Event) {
  603.                         event = details;
  604.                     }
  605.                     else {
  606.                         event = new Event(_eventType_);
  607.                         if (details) {
  608.                             Object.keys(details).forEach((keyName) => {
  609.                                 event[keyName] = details[keyName];
  610.                             });
  611.                         }
  612.                     }
  613.                     if (useDispatchToTriggerEvent == false && _eventType_ in events) {
  614.                         events[_eventType_].forEach((eventsItem) => {
  615.                             eventsItem.callback(event);
  616.                         });
  617.                     }
  618.                     else {
  619.                         elementItem.dispatchEvent(event);
  620.                     }
  621.                 });
  622.             });
  623.         }
  624.         /**
  625.          * 绑定或触发元素的click事件
  626.          * @param element 目标元素
  627.          * @param handler （可选）事件处理函数
  628.          * @param details （可选）赋予触发的Event的额外属性
  629.          * @param useDispatchToTriggerEvent （可选）是否使用dispatchEvent来触发事件,默认true
  630.          * @example
  631.          * // 触发元素a.xx的click事件
  632.          * DOMUtils.click(document.querySelector("a.xx"))
  633.          * DOMUtils.click("a.xx")
  634.          * DOMUtils.click("a.xx"，function(){
  635.          *  console.log("触发click事件成功")
  636.          * })
  637.          * */
  638.         click(element, handler, details, useDispatchToTriggerEvent) {
  639.             let DOMUtilsContext = this;
  640.             if (typeof element === "string") {
  641.                 element = DOMUtilsContext.selectorAll(element);
  642.             }
  643.             if (element == null) {
  644.                 return;
  645.             }
  646.             if (isNodeList(element)) {
  647.                 // 设置
  648.                 element.forEach(($ele) => {
  649.                     DOMUtilsContext.click($ele, handler, details, useDispatchToTriggerEvent);
  650.                 });
  651.                 return;
  652.             }
  653.             if (handler == null) {
  654.                 DOMUtilsContext.trigger(element, "click", details, useDispatchToTriggerEvent);
  655.             }
  656.             else {
  657.                 DOMUtilsContext.on(element, "click", null, handler);
  658.             }
  659.         }
  660.         /**
  661.          * 绑定或触发元素的blur事件
  662.          * @param element 目标元素
  663.          * @param handler （可选）事件处理函数
  664.          * @param details （可选）赋予触发的Event的额外属性
  665.          * @param useDispatchToTriggerEvent （可选）是否使用dispatchEvent来触发事件,默认true
  666.          * @example
  667.          * // 触发元素a.xx的blur事件
  668.          * DOMUtils.blur(document.querySelector("a.xx"))
  669.          * DOMUtils.blur("a.xx")
  670.          * DOMUtils.blur("a.xx"，function(){
  671.          *  console.log("触发blur事件成功")
  672.          * })
  673.          * */
  674.         blur(element, handler, details, useDispatchToTriggerEvent) {
  675.             let DOMUtilsContext = this;
  676.             if (typeof element === "string") {
  677.                 element = DOMUtilsContext.selectorAll(element);
  678.             }
  679.             if (element == null) {
  680.                 return;
  681.             }
  682.             if (isNodeList(element)) {
  683.                 // 设置
  684.                 element.forEach(($ele) => {
  685.                     DOMUtilsContext.focus($ele, handler, details, useDispatchToTriggerEvent);
  686.                 });
  687.                 return;
  688.             }
  689.             if (handler === null) {
  690.                 DOMUtilsContext.trigger(element, "blur", details, useDispatchToTriggerEvent);
  691.             }
  692.             else {
  693.                 DOMUtilsContext.on(element, "blur", null, handler);
  694.             }
  695.         }
  696.         /**
  697.          * 绑定或触发元素的focus事件
  698.          * @param element 目标元素
  699.          * @param handler （可选）事件处理函数
  700.          * @param details （可选）赋予触发的Event的额外属性
  701.          * @param useDispatchToTriggerEvent （可选）是否使用dispatchEvent来触发事件,默认true
  702.          * @example
  703.          * // 触发元素a.xx的focus事件
  704.          * DOMUtils.focus(document.querySelector("a.xx"))
  705.          * DOMUtils.focus("a.xx")
  706.          * DOMUtils.focus("a.xx"，function(){
  707.          *  console.log("触发focus事件成功")
  708.          * })
  709.          * */
  710.         focus(element, handler, details, useDispatchToTriggerEvent) {
  711.             let DOMUtilsContext = this;
  712.             if (typeof element === "string") {
  713.                 element = DOMUtilsContext.selectorAll(element);
  714.             }
  715.             if (element == null) {
  716.                 return;
  717.             }
  718.             if (isNodeList(element)) {
  719.                 // 设置
  720.                 element.forEach(($ele) => {
  721.                     DOMUtilsContext.focus($ele, handler, details, useDispatchToTriggerEvent);
  722.                 });
  723.                 return;
  724.             }
  725.             if (handler == null) {
  726.                 DOMUtilsContext.trigger(element, "focus", details, useDispatchToTriggerEvent);
  727.             }
  728.             else {
  729.                 DOMUtilsContext.on(element, "focus", null, handler);
  730.             }
  731.         }
  732.         /**
  733.          * 当鼠标移入或移出元素时触发事件
  734.          * @param element 当前元素
  735.          * @param handler 事件处理函数
  736.          * @param option 配置
  737.          * @example
  738.          * // 监听a.xx元素的移入或移出
  739.          * DOMUtils.hover(document.querySelector("a.xx"),()=>{
  740.          *   console.log("移入/移除");
  741.          * })
  742.          * DOMUtils.hover("a.xx",()=>{
  743.          *   console.log("移入/移除");
  744.          * })
  745.          */
  746.         hover(element, handler, option) {
  747.             let DOMUtilsContext = this;
  748.             if (typeof element === "string") {
  749.                 element = DOMUtilsContext.selectorAll(element);
  750.             }
  751.             if (element == null) {
  752.                 return;
  753.             }
  754.             if (isNodeList(element)) {
  755.                 // 设置
  756.                 element.forEach(($ele) => {
  757.                     DOMUtilsContext.hover($ele, handler, option);
  758.                 });
  759.                 return;
  760.             }
  761.             DOMUtilsContext.on(element, "mouseenter", null, handler, option);
  762.             DOMUtilsContext.on(element, "mouseleave", null, handler, option);
  763.         }
  764.         /**
  765.          * 当按键松开时触发事件
  766.          * keydown - > keypress - > keyup
  767.          * @param element 当前元素
  768.          * @param handler 事件处理函数
  769.          * @param option 配置
  770.          * @example
  771.          * // 监听a.xx元素的按键松开
  772.          * DOMUtils.keyup(document.querySelector("a.xx"),()=>{
  773.          *   console.log("按键松开");
  774.          * })
  775.          * DOMUtils.keyup("a.xx",()=>{
  776.          *   console.log("按键松开");
  777.          * })
  778.          */
  779.         keyup(element, handler, option) {
  780.             let DOMUtilsContext = this;
  781.             if (element == null) {
  782.                 return;
  783.             }
  784.             if (typeof element === "string") {
  785.                 element = DOMUtilsContext.selectorAll(element);
  786.             }
  787.             if (isNodeList(element)) {
  788.                 // 设置
  789.                 element.forEach(($ele) => {
  790.                     DOMUtilsContext.keyup($ele, handler, option);
  791.                 });
  792.                 return;
  793.             }
  794.             DOMUtilsContext.on(element, "keyup", null, handler, option);
  795.         }
  796.         /**
  797.          * 当按键按下时触发事件
  798.          * keydown - > keypress - > keyup
  799.          * @param element 目标
  800.          * @param handler 事件处理函数
  801.          * @param option 配置
  802.          * @example
  803.          * // 监听a.xx元素的按键按下
  804.          * DOMUtils.keydown(document.querySelector("a.xx"),()=>{
  805.          *   console.log("按键按下");
  806.          * })
  807.          * DOMUtils.keydown("a.xx",()=>{
  808.          *   console.log("按键按下");
  809.          * })
  810.          */
  811.         keydown(element, handler, option) {
  812.             let DOMUtilsContext = this;
  813.             if (element == null) {
  814.                 return;
  815.             }
  816.             if (typeof element === "string") {
  817.                 element = DOMUtilsContext.selectorAll(element);
  818.             }
  819.             if (isNodeList(element)) {
  820.                 // 设置
  821.                 element.forEach(($ele) => {
  822.                     DOMUtilsContext.keydown($ele, handler, option);
  823.                 });
  824.                 return;
  825.             }
  826.             DOMUtilsContext.on(element, "keydown", null, handler, option);
  827.         }
  828.         /**
  829.          * 当按键按下时触发事件
  830.          * keydown - > keypress - > keyup
  831.          * @param element 目标
  832.          * @param handler 事件处理函数
  833.          * @param option 配置
  834.          * @example
  835.          * // 监听a.xx元素的按键按下
  836.          * DOMUtils.keypress(document.querySelector("a.xx"),()=>{
  837.          *   console.log("按键按下");
  838.          * })
  839.          * DOMUtils.keypress("a.xx",()=>{
  840.          *   console.log("按键按下");
  841.          * })
  842.          */
  843.         keypress(element, handler, option) {
  844.             let DOMUtilsContext = this;
  845.             if (element == null) {
  846.                 return;
  847.             }
  848.             if (typeof element === "string") {
  849.                 element = DOMUtilsContext.selectorAll(element);
  850.             }
  851.             if (isNodeList(element)) {
  852.                 // 设置
  853.                 element.forEach(($ele) => {
  854.                     DOMUtilsContext.keypress($ele, handler, option);
  855.                 });
  856.                 return;
  857.             }
  858.             DOMUtilsContext.on(element, "keypress", null, handler, option);
  859.         }
  860.         /**
  861.          * 监听某个元素键盘按键事件或window全局按键事件
  862.          * 按下有值的键时触发，按下Ctrl\Alt\Shift\Meta是无值键。按下先触发keydown事件，再触发keypress事件。
  863.          * @param element 需要监听的对象，可以是全局Window或者某个元素
  864.          * @param eventName 事件名，默认keypress
  865.          * @param callback 自己定义的回调事件，参数1为当前的key，参数2为组合按键，数组类型，包含ctrl、shift、alt和meta（win键或mac的cmd键）
  866.          * @param options 监听事件的配置
  867.          * @example
  868.             Utils.listenKeyboard(window,(keyName,keyValue,otherKey,event)=>{
  869.                 if(keyName === "Enter"){
  870.                     console.log("回车按键的值是："+keyValue)
  871.                 }
  872.                 if(otherKey.indexOf("ctrl") && keyName === "Enter" ){
  873.                     console.log("Ctrl和回车键");
  874.               }
  875.             })
  876.          * @example
  877.         字母和数字键的键码值(keyCode)
  878.           按键	键码	按键	键码	按键	键码	按键	键码
  879.           A	65	J	74	S	83	1	49
  880.           B	66	K	75	T	84	2	50
  881.           C	67	L	76	U	85	3	51
  882.           D	68	M	77	V	86	4	52
  883.           E	69	N	78	W	87	5	53
  884.           F	70	O	79	X	88	6	54
  885.           G	71	P	80	Y	89	7	55
  886.           H	72	Q	81	Z	90	8	56
  887.           I	73	R	82	0	48	9	57
  888.       
  889.           数字键盘上的键的键码值(keyCode)
  890.           功能键键码值(keyCode)
  891.           按键	键码	按键  	键码	按键	键码	按键	键码
  892.           0	96	8	104	F1	112	F7	118
  893.           1	97	9	105	F2	113	F8	119
  894.           2	98	*	106	F3	114	F9	120
  895.           3	99	+	107	F4	115	F10	121
  896.           4	100	Enter	108	F5	116	F11	122
  897.           5	101	-	109	F6	117	F12	123
  898.           6	102	.	110
  899.           7	103	/	111
  900.           
  901.           控制键键码值(keyCode)
  902.           按键		键码	按键		键码	按键		键码	按键		键码
  903.           BackSpace	8	Esc		27	→		39	-_		189
  904.           Tab		9	Spacebar	32	↓		40	.>		190
  905.           Clear		12	Page Up		33	Insert		45	/?		191
  906.           Enter		13	Page Down	34	Delete		46	`~		192
  907.           Shift		16	End		35	Num Lock	144	[{		219
  908.           Control		17	Home		36	;:		186	\|		220
  909.           Alt		18	←		37	=+		187	]}		221
  910.           Cape Lock	20	↑		38	,<		188	'"		222
  911.       
  912.           多媒体键码值(keyCode)
  913.           按键		键码
  914.           音量加		175
  915.           音量减		174
  916.           停止		179
  917.           静音		173
  918.           浏览器		172
  919.           邮件		180
  920.           搜索		170
  921.           收藏		171
  922.          **/
  923.         listenKeyboard(element, eventName = "keypress", callback, options) {
  924.             let DOMUtilsContext = this;
  925.             if (typeof element === "string") {
  926.                 element = DOMUtilsContext.selectorAll(element);
  927.             }
  928.             let keyboardEventCallBack = function (event) {
  929.                 /** 键名 */
  930.                 let keyName = event.key || event.code;
  931.                 /** 键值 */
  932.                 let keyValue = event.charCode || event.keyCode || event.which;
  933.                 /** 组合键列表 */
  934.                 let otherCodeList = [];
  935.                 if (event.ctrlKey) {
  936.                     otherCodeList.push("ctrl");
  937.                 }
  938.                 if (event.altKey) {
  939.                     otherCodeList.push("alt");
  940.                 }
  941.                 if (event.metaKey) {
  942.                     otherCodeList.push("meta");
  943.                 }
  944.                 if (event.shiftKey) {
  945.                     otherCodeList.push("shift");
  946.                 }
  947.                 if (typeof callback === "function") {
  948.                     callback(keyName, keyValue, otherCodeList, event);
  949.                 }
  950.             };
  951.             DOMUtilsContext.on(element, eventName, keyboardEventCallBack, options);
  952.             return {
  953.                 removeListen: () => {
  954.                     DOMUtilsContext.off(element, eventName, keyboardEventCallBack, options);
  955.                 },
  956.             };
  957.         }
  958.         selector(selector) {
  959.             return this.selectorAll(selector)[0];
  960.         }
  961.         selectorAll(selector) {
  962.             const context = this;
  963.             selector = selector.trim();
  964.             if (selector.match(/[^\s]{1}:empty$/gi)) {
  965.                 // empty 语法
  966.                 selector = selector.replace(/:empty$/gi, "");
  967.                 return Array.from(context.windowApi.document.querySelectorAll(selector)).filter(($ele) => {
  968.                     return $ele?.innerHTML?.trim() === "";
  969.                 });
  970.             }
  971.             else if (selector.match(/[^\s]{1}:contains\("(.*)"\)$/i) ||
  972.                 selector.match(/[^\s]{1}:contains\('(.*)'\)$/i)) {
  973.                 // contains 语法
  974.                 let textMatch = selector.match(/:contains\(("|')(.*)("|')\)$/i);
  975.                 let text = textMatch[2];
  976.                 selector = selector.replace(/:contains\(("|')(.*)("|')\)$/gi, "");
  977.                 return Array.from(context.windowApi.document.querySelectorAll(selector)).filter(($ele) => {
  978.                     // @ts-ignore
  979.                     return ($ele?.textContent || $ele?.innerText)?.includes(text);
  980.                 });
  981.             }
  982.             else if (selector.match(/[^\s]{1}:regexp\("(.*)"\)$/i) ||
  983.                 selector.match(/[^\s]{1}:regexp\('(.*)'\)$/i)) {
  984.                 // regexp 语法
  985.                 let textMatch = selector.match(/:regexp\(("|')(.*)("|')\)$/i);
  986.                 let pattern = textMatch[2];
  987.                 let flagMatch = pattern.match(/("|'),[\s]*("|')([igm]{0,3})$/i);
  988.                 let flags = "";
  989.                 if (flagMatch) {
  990.                     pattern = pattern.replace(/("|'),[\s]*("|')([igm]{0,3})$/gi, "");
  991.                     flags = flagMatch[3];
  992.                 }
  993.                 let regexp = new RegExp(pattern, flags);
  994.                 selector = selector.replace(/:regexp\(("|')(.*)("|')\)$/gi, "");
  995.                 return Array.from(context.windowApi.document.querySelectorAll(selector)).filter(($ele) => {
  996.                     // @ts-ignore
  997.                     return Boolean(($ele?.textContent || $ele?.innerText)?.match(regexp));
  998.                 });
  999.             }
  1000.             else {
  1001.                 // 普通语法
  1002.                 return Array.from(context.windowApi.document.querySelectorAll(selector));
  1003.             }
  1004.         }
  1005.     }
  1006.  
  1007.     /**
  1008.      * 判断是否是元素列表
  1009.      * @param $ele
  1010.      */
  1011.     const isNodeList = ($ele) => {
  1012.         return Array.isArray($ele) || $ele instanceof NodeList;
  1013.     };
  1014.     class DOMUtils extends DOMUtilsEvent {
  1015.         constructor(option) {
  1016.             super(option);
  1017.         }
  1018.         /** 版本号 */
  1019.         version = "2024.12.3";
  1020.         attr(element, attrName, attrValue) {
  1021.             let DOMUtilsContext = this;
  1022.             if (typeof element === "string") {
  1023.                 element = DOMUtilsContext.selectorAll(element);
  1024.             }
  1025.             if (element == null) {
  1026.                 return;
  1027.             }
  1028.             if (isNodeList(element)) {
  1029.                 if (attrValue == null) {
  1030.                     // 获取属性
  1031.                     return DOMUtilsContext.attr(element[0], attrName, attrValue);
  1032.                 }
  1033.                 else {
  1034.                     // 设置属性
  1035.                     element.forEach(($ele) => {
  1036.                         DOMUtilsContext.attr($ele, attrName, attrValue);
  1037.                     });
  1038.                     return;
  1039.                 }
  1040.             }
  1041.             if (attrValue == null) {
  1042.                 return element.getAttribute(attrName);
  1043.             }
  1044.             else {
  1045.                 element.setAttribute(attrName, attrValue);
  1046.             }
  1047.         }
  1048.         /**
  1049.          * 创建元素
  1050.          * @param tagName 标签名
  1051.          * @param property 属性
  1052.          * @param attributes 元素上的自定义属性
  1053.          * @example
  1054.          * // 创建一个DIV元素，且属性class为xxx
  1055.          * DOMUtils.createElement("div",undefined,{ class:"xxx" });
  1056.          * > <div class="xxx"></div>
  1057.          * @example
  1058.          * // 创建一个DIV元素
  1059.          * DOMUtils.createElement("div");
  1060.          * > <div></div>
  1061.          * @example
  1062.          * // 创建一个DIV元素
  1063.          * DOMUtils.createElement("div","测试");
  1064.          * > <div>测试</div>
  1065.          */
  1066.         createElement(
  1067.         /** 元素名 */
  1068.         tagName, 
  1069.         /** 属性 */
  1070.         property, 
  1071.         /** 自定义属性 */
  1072.         attributes) {
  1073.             let DOMUtilsContext = this;
  1074.             let tempElement = DOMUtilsContext.windowApi.document.createElement(tagName);
  1075.             if (typeof property === "string") {
  1076.                 tempElement.innerHTML = property;
  1077.                 return tempElement;
  1078.             }
  1079.             if (property == null) {
  1080.                 property = {};
  1081.             }
  1082.             if (attributes == null) {
  1083.                 attributes = {};
  1084.             }
  1085.             Object.keys(property).forEach((key) => {
  1086.                 let value = property[key];
  1087.                 tempElement[key] = value;
  1088.             });
  1089.             Object.keys(attributes).forEach((key) => {
  1090.                 let value = attributes[key];
  1091.                 if (typeof value === "object") {
  1092.                     /* object转字符串 */
  1093.                     value = JSON.stringify(value);
  1094.                 }
  1095.                 else if (typeof value === "function") {
  1096.                     /* function转字符串 */
  1097.                     value = value.toString();
  1098.                 }
  1099.                 tempElement.setAttribute(key, value);
  1100.             });
  1101.             return tempElement;
  1102.         }
  1103.         css(element, property, value) {
  1104.             let DOMUtilsContext = this;
  1105.             /**
  1106.              * 把纯数字没有px的加上
  1107.              */
  1108.             function handlePixe(propertyName, propertyValue) {
  1109.                 let allowAddPixe = [
  1110.                     "width",
  1111.                     "height",
  1112.                     "top",
  1113.                     "left",
  1114.                     "right",
  1115.                     "bottom",
  1116.                     "font-size",
  1117.                 ];
  1118.                 if (typeof propertyValue === "number") {
  1119.                     propertyValue = propertyValue.toString();
  1120.                 }
  1121.                 if (typeof propertyValue === "string" &&
  1122.                     allowAddPixe.includes(propertyName) &&
  1123.                     propertyValue.match(/[0-9]$/gi)) {
  1124.                     propertyValue = propertyValue + "px";
  1125.                 }
  1126.                 return propertyValue;
  1127.             }
  1128.             if (typeof element === "string") {
  1129.                 element = DOMUtilsContext.selectorAll(element);
  1130.             }
  1131.             if (element == null) {
  1132.                 return;
  1133.             }
  1134.             if (isNodeList(element)) {
  1135.                 if (typeof property === "string") {
  1136.                     if (value == null) {
  1137.                         // 获取属性
  1138.                         return DOMUtilsContext.css(element[0], property);
  1139.                     }
  1140.                     else {
  1141.                         // 设置属性
  1142.                         element.forEach(($ele) => {
  1143.                             DOMUtilsContext.css($ele, property);
  1144.                         });
  1145.                         return;
  1146.                     }
  1147.                 }
  1148.                 else if (typeof property === "object") {
  1149.                     // 设置属性
  1150.                     element.forEach(($ele) => {
  1151.                         DOMUtilsContext.css($ele, property);
  1152.                     });
  1153.                     return;
  1154.                 }
  1155.                 else ;
  1156.                 return;
  1157.             }
  1158.             if (typeof property === "string") {
  1159.                 if (value == null) {
  1160.                     return DOMUtilsContext.windowApi.globalThis
  1161.                         .getComputedStyle(element)
  1162.                         .getPropertyValue(property);
  1163.                 }
  1164.                 else {
  1165.                     if (value === "string" && value.includes("!important")) {
  1166.                         element.style.setProperty(property, value, "important");
  1167.                     }
  1168.                     else {
  1169.                         value = handlePixe(property, value);
  1170.                         element.style.setProperty(property, value);
  1171.                     }
  1172.                 }
  1173.             }
  1174.             else if (typeof property === "object") {
  1175.                 for (let prop in property) {
  1176.                     if (typeof property[prop] === "string" &&
  1177.                         property[prop].includes("!important")) {
  1178.                         element.style.setProperty(prop, property[prop], "important");
  1179.                     }
  1180.                     else {
  1181.                         property[prop] = handlePixe(prop, property[prop]);
  1182.                         element.style.setProperty(prop, property[prop]);
  1183.                     }
  1184.                 }
  1185.             }
  1186.             else ;
  1187.         }
  1188.         text(element, text) {
  1189.             let DOMUtilsContext = this;
  1190.             if (typeof element === "string") {
  1191.                 element = DOMUtilsContext.selectorAll(element);
  1192.             }
  1193.             if (element == null) {
  1194.                 return;
  1195.             }
  1196.             if (isNodeList(element)) {
  1197.                 if (text == null) {
  1198.                     // 获取
  1199.                     return DOMUtilsContext.text(element[0]);
  1200.                 }
  1201.                 else {
  1202.                     // 设置
  1203.                     element.forEach(($ele) => {
  1204.                         DOMUtilsContext.text($ele, text);
  1205.                     });
  1206.                 }
  1207.                 return;
  1208.             }
  1209.             if (text == null) {
  1210.                 return element.textContent || element.innerText;
  1211.             }
  1212.             else {
  1213.                 if (text instanceof Node) {
  1214.                     text = text.textContent || text.innerText;
  1215.                 }
  1216.                 if ("textContent" in element) {
  1217.                     element.textContent = text;
  1218.                 }
  1219.                 else if ("innerText" in element) {
  1220.                     element.innerText = text;
  1221.                 }
  1222.             }
  1223.         }
  1224.         html(element, html) {
  1225.             let DOMUtilsContext = this;
  1226.             if (typeof element === "string") {
  1227.                 element = DOMUtilsContext.selectorAll(element);
  1228.             }
  1229.             if (element == null) {
  1230.                 return;
  1231.             }
  1232.             if (isNodeList(element)) {
  1233.                 if (html == null) {
  1234.                     // 获取
  1235.                     return DOMUtilsContext.html(element[0]);
  1236.                 }
  1237.                 else {
  1238.                     // 设置
  1239.                     element.forEach(($ele) => {
  1240.                         DOMUtilsContext.html($ele, html);
  1241.                     });
  1242.                 }
  1243.                 return;
  1244.             }
  1245.             if (html == null) {
  1246.                 // 获取
  1247.                 return element.innerHTML;
  1248.             }
  1249.             else {
  1250.                 // 设置
  1251.                 if (html instanceof Element) {
  1252.                     html = html.innerHTML;
  1253.                 }
  1254.                 if ("innerHTML" in element) {
  1255.                     element.innerHTML = html;
  1256.                 }
  1257.             }
  1258.         }
  1259.         /**
  1260.          * 获取移动元素的transform偏移
  1261.          */
  1262.         getTransform(element, isShow = false) {
  1263.             let DOMUtilsContext = this;
  1264.             let transform_left = 0;
  1265.             let transform_top = 0;
  1266.             if (!(isShow || (!isShow && DOMUtilsCommonUtils.isShow(element)))) {
  1267.                 /* 未显示 */
  1268.                 let { recovery } = DOMUtilsCommonUtils.showElement(element);
  1269.                 let transformInfo = DOMUtilsContext.getTransform(element, true);
  1270.                 recovery();
  1271.                 return transformInfo;
  1272.             }
  1273.             let elementTransform = DOMUtilsContext.windowApi.globalThis.getComputedStyle(element).transform;
  1274.             if (elementTransform != null &&
  1275.                 elementTransform !== "none" &&
  1276.                 elementTransform !== "") {
  1277.                 let elementTransformSplit = elementTransform
  1278.                     .match(/\((.+)\)/)?.[1]
  1279.                     .split(",");
  1280.                 if (elementTransformSplit) {
  1281.                     transform_left = Math.abs(parseInt(elementTransformSplit[4]));
  1282.                     transform_top = Math.abs(parseInt(elementTransformSplit[5]));
  1283.                 }
  1284.                 else {
  1285.                     transform_left = 0;
  1286.                     transform_top = 0;
  1287.                 }
  1288.             }
  1289.             return {
  1290.                 transformLeft: transform_left,
  1291.                 transformTop: transform_top,
  1292.             };
  1293.         }
  1294.         val(element, value) {
  1295.             let DOMUtilsContext = this;
  1296.             if (typeof element === "string") {
  1297.                 element = DOMUtilsContext.selectorAll(element);
  1298.             }
  1299.             if (element == null) {
  1300.                 return;
  1301.             }
  1302.             if (isNodeList(element)) {
  1303.                 if (value == null) {
  1304.                     // 获取
  1305.                     return DOMUtilsContext.val(element[0]);
  1306.                 }
  1307.                 else {
  1308.                     // 设置
  1309.                     element.forEach(($ele) => {
  1310.                         DOMUtilsContext.val($ele, value);
  1311.                     });
  1312.                 }
  1313.                 return;
  1314.             }
  1315.             if (value == null) {
  1316.                 // 获取
  1317.                 if (element.localName === "input" &&
  1318.                     (element.type === "checkbox" || element.type === "radio")) {
  1319.                     return element.checked;
  1320.                 }
  1321.                 else {
  1322.                     return element.value;
  1323.                 }
  1324.             }
  1325.             else {
  1326.                 // 设置
  1327.                 if (element.localName === "input" &&
  1328.                     (element.type === "checkbox" || element.type === "radio")) {
  1329.                     element.checked = !!value;
  1330.                 }
  1331.                 else {
  1332.                     element.value = value;
  1333.                 }
  1334.             }
  1335.         }
  1336.         prop(element, propName, propValue) {
  1337.             let DOMUtilsContext = this;
  1338.             if (typeof element === "string") {
  1339.                 element = DOMUtilsContext.selectorAll(element);
  1340.             }
  1341.             if (element == null) {
  1342.                 return;
  1343.             }
  1344.             if (isNodeList(element)) {
  1345.                 if (propValue == null) {
  1346.                     // 获取
  1347.                     return DOMUtilsContext.prop(element[0], propName);
  1348.                 }
  1349.                 else {
  1350.                     // 设置
  1351.                     element.forEach(($ele) => {
  1352.                         DOMUtilsContext.prop($ele, propName, propValue);
  1353.                     });
  1354.                 }
  1355.                 return;
  1356.             }
  1357.             if (propValue == null) {
  1358.                 return Reflect.get(element, propName);
  1359.             }
  1360.             else {
  1361.                 Reflect.set(element, propName, propValue);
  1362.             }
  1363.         }
  1364.         /**
  1365.          * 移除元素的属性
  1366.          * @param element 目标元素
  1367.          * @param attrName 属性名
  1368.          * @example
  1369.          * // 移除元素a.xx的属性data-value
  1370.          * DOMUtils.removeAttr(document.querySelector("a.xx"),"data-value")
  1371.          * DOMUtils.removeAttr("a.xx","data-value")
  1372.          * */
  1373.         removeAttr(element, attrName) {
  1374.             let DOMUtilsContext = this;
  1375.             if (typeof element === "string") {
  1376.                 element = DOMUtilsContext.selectorAll(element);
  1377.             }
  1378.             if (element == null) {
  1379.                 return;
  1380.             }
  1381.             if (isNodeList(element)) {
  1382.                 // 设置
  1383.                 element.forEach(($ele) => {
  1384.                     DOMUtilsContext.removeAttr($ele, attrName);
  1385.                 });
  1386.                 return;
  1387.             }
  1388.             element.removeAttribute(attrName);
  1389.         }
  1390.         /**
  1391.          * 移除元素class名
  1392.          * @param element 目标元素
  1393.          * @param className 类名
  1394.          * @example
  1395.          * // 移除元素a.xx的className为xx
  1396.          * DOMUtils.removeClass(document.querySelector("a.xx"),"xx")
  1397.          * DOMUtils.removeClass("a.xx","xx")
  1398.          */
  1399.         removeClass(element, className) {
  1400.             let DOMUtilsContext = this;
  1401.             if (typeof element === "string") {
  1402.                 element = DOMUtilsContext.selectorAll(element);
  1403.             }
  1404.             if (element == null) {
  1405.                 return;
  1406.             }
  1407.             if (isNodeList(element)) {
  1408.                 // 设置
  1409.                 element.forEach(($ele) => {
  1410.                     DOMUtilsContext.removeClass($ele, className);
  1411.                 });
  1412.                 return;
  1413.             }
  1414.             if (className == null) {
  1415.                 // 清空全部className
  1416.                 element.className = "";
  1417.             }
  1418.             else {
  1419.                 if (!Array.isArray(className)) {
  1420.                     className = className.split(" ");
  1421.                 }
  1422.                 className.forEach((itemClassName) => {
  1423.                     element.classList.remove(itemClassName);
  1424.                 });
  1425.             }
  1426.         }
  1427.         /**
  1428.          * 移除元素的属性
  1429.          * @param element 目标元素
  1430.          * @param propName 属性名
  1431.          * @example
  1432.          * // 移除元素a.xx的href属性
  1433.          * DOMUtils.removeProp(document.querySelector("a.xx"),"href")
  1434.          * DOMUtils.removeProp("a.xx","href")
  1435.          * */
  1436.         removeProp(element, propName) {
  1437.             let DOMUtilsContext = this;
  1438.             if (typeof element === "string") {
  1439.                 element = DOMUtilsContext.selectorAll(element);
  1440.             }
  1441.             if (element == null) {
  1442.                 return;
  1443.             }
  1444.             if (isNodeList(element)) {
  1445.                 // 设置
  1446.                 element.forEach(($ele) => {
  1447.                     DOMUtilsContext.removeProp($ele, propName);
  1448.                 });
  1449.                 return;
  1450.             }
  1451.             DOMUtilsCommonUtils.delete(element, propName);
  1452.         }
  1453.         /**
  1454.          * 将一个元素替换为另一个元素
  1455.          * @param element 目标元素
  1456.          * @param newElement 新元素
  1457.          * @example
  1458.          * // 替换元素a.xx为b.xx
  1459.          * DOMUtils.replaceWith(document.querySelector("a.xx"),document.querySelector("b.xx"))
  1460.          * DOMUtils.replaceWith("a.xx",'<b class="xx"></b>')
  1461.          */
  1462.         replaceWith(element, newElement) {
  1463.             let DOMUtilsContext = this;
  1464.             if (typeof element === "string") {
  1465.                 element = DOMUtilsContext.selectorAll(element);
  1466.             }
  1467.             if (element == null) {
  1468.                 return;
  1469.             }
  1470.             if (isNodeList(element)) {
  1471.                 // 设置
  1472.                 element.forEach(($ele) => {
  1473.                     DOMUtilsContext.replaceWith($ele, newElement);
  1474.                 });
  1475.                 return;
  1476.             }
  1477.             if (typeof newElement === "string") {
  1478.                 newElement = DOMUtilsContext.parseHTML(newElement, false, false);
  1479.             }
  1480.             element.parentElement.replaceChild(newElement, element);
  1481.         }
  1482.         /**
  1483.          * 给元素添加class
  1484.          * @param element 目标元素
  1485.          * @param className class名
  1486.          * @example
  1487.          * // 元素a.xx的className添加_vue_
  1488.          * DOMUtils.addClass(document.querySelector("a.xx"),"_vue_")
  1489.          * DOMUtils.addClass("a.xx","_vue_")
  1490.          * */
  1491.         addClass(element, className) {
  1492.             let DOMUtilsContext = this;
  1493.             if (typeof element === "string") {
  1494.                 element = DOMUtilsContext.selectorAll(element);
  1495.             }
  1496.             if (element == null) {
  1497.                 return;
  1498.             }
  1499.             if (isNodeList(element)) {
  1500.                 // 设置
  1501.                 element.forEach(($ele) => {
  1502.                     DOMUtilsContext.addClass($ele, className);
  1503.                 });
  1504.                 return;
  1505.             }
  1506.             if (!Array.isArray(className)) {
  1507.                 className = className.split(" ");
  1508.             }
  1509.             className.forEach((itemClassName) => {
  1510.                 if (itemClassName.trim() == "") {
  1511.                     return;
  1512.                 }
  1513.                 element.classList.add(itemClassName);
  1514.             });
  1515.         }
  1516.         /**
  1517.          * 判断元素是否存在className
  1518.          * @param element
  1519.          * @param className
  1520.          */
  1521.         hasClass(element, className) {
  1522.             let DOMUtilsContext = this;
  1523.             if (typeof element === "string") {
  1524.                 element = DOMUtilsContext.selectorAll(element);
  1525.             }
  1526.             if (element == null) {
  1527.                 return false;
  1528.             }
  1529.             if (isNodeList(element)) {
  1530.                 let flag = true;
  1531.                 for (let index = 0; index < element.length; index++) {
  1532.                     const $ele = element[index];
  1533.                     flag = flag && DOMUtilsContext.hasClass($ele, className);
  1534.                 }
  1535.                 return flag;
  1536.             }
  1537.             if (!element?.classList) {
  1538.                 return false;
  1539.             }
  1540.             if (!Array.isArray(className)) {
  1541.                 className = className.split(" ");
  1542.             }
  1543.             for (let index = 0; index < className.length; index++) {
  1544.                 const item = className[index].trim();
  1545.                 if (!element.classList.contains(item)) {
  1546.                     return false;
  1547.                 }
  1548.             }
  1549.             return true;
  1550.         }
  1551.         /**
  1552.          * 函数在元素内部末尾添加子元素或HTML字符串
  1553.          * @param element 目标元素
  1554.          * @param content 子元素或HTML字符串
  1555.          * @example
  1556.          * // 元素a.xx的内部末尾添加一个元素
  1557.          * DOMUtils.append(document.querySelector("a.xx"),document.querySelector("b.xx"))
  1558.          * DOMUtils.append("a.xx","'<b class="xx"></b>")
  1559.          * */
  1560.         append(element, content) {
  1561.             let DOMUtilsContext = this;
  1562.             if (typeof element === "string") {
  1563.                 element = DOMUtilsContext.selectorAll(element);
  1564.             }
  1565.             if (element == null) {
  1566.                 return;
  1567.             }
  1568.             if (isNodeList(element)) {
  1569.                 // 设置
  1570.                 element.forEach(($ele) => {
  1571.                     DOMUtilsContext.append($ele, content);
  1572.                 });
  1573.                 return;
  1574.             }
  1575.             function elementAppendChild(ele, text) {
  1576.                 if (typeof content === "string") {
  1577.                     ele.insertAdjacentHTML("beforeend", text);
  1578.                 }
  1579.                 else {
  1580.                     ele.appendChild(text);
  1581.                 }
  1582.             }
  1583.             if (Array.isArray(content) || content instanceof NodeList) {
  1584.                 /* 数组 */
  1585.                 let fragment = DOMUtilsContext.windowApi.document.createDocumentFragment();
  1586.                 content.forEach((ele) => {
  1587.                     if (typeof ele === "string") {
  1588.                         ele = DOMUtilsContext.parseHTML(ele, true, false);
  1589.                     }
  1590.                     fragment.appendChild(ele);
  1591.                 });
  1592.                 element.appendChild(fragment);
  1593.             }
  1594.             else {
  1595.                 elementAppendChild(element, content);
  1596.             }
  1597.         }
  1598.         /**
  1599.          * 函数 在元素内部开头添加子元素或HTML字符串
  1600.          * @param element 目标元素
  1601.          * @param content 子元素或HTML字符串
  1602.          * @example
  1603.          * // 元素a.xx内部开头添加一个元素
  1604.          * DOMUtils.prepend(document.querySelector("a.xx"),document.querySelector("b.xx"))
  1605.          * DOMUtils.prepend("a.xx","'<b class="xx"></b>")
  1606.          * */
  1607.         prepend(element, content) {
  1608.             let DOMUtilsContext = this;
  1609.             if (typeof element === "string") {
  1610.                 element = DOMUtilsContext.selectorAll(element);
  1611.             }
  1612.             if (element == null) {
  1613.                 return;
  1614.             }
  1615.             if (isNodeList(element)) {
  1616.                 // 设置
  1617.                 element.forEach(($ele) => {
  1618.                     DOMUtilsContext.prepend($ele, content);
  1619.                 });
  1620.                 return;
  1621.             }
  1622.             if (typeof content === "string") {
  1623.                 element.insertAdjacentHTML("afterbegin", content);
  1624.             }
  1625.             else {
  1626.                 let $firstChild = element.firstChild;
  1627.                 if ($firstChild == null) {
  1628.                     element.prepend(content);
  1629.                 }
  1630.                 else {
  1631.                     element.insertBefore(content, element.firstChild);
  1632.                 }
  1633.             }
  1634.         }
  1635.         /**
  1636.          * 在元素后面添加兄弟元素或HTML字符串
  1637.          * @param element 目标元素
  1638.          * @param content 兄弟元素或HTML字符串
  1639.          * @example
  1640.          * // 元素a.xx后面添加一个元素
  1641.          * DOMUtils.after(document.querySelector("a.xx"),document.querySelector("b.xx"))
  1642.          * DOMUtils.after("a.xx","'<b class="xx"></b>")
  1643.          * */
  1644.         after(element, content) {
  1645.             let DOMUtilsContext = this;
  1646.             if (typeof element === "string") {
  1647.                 element = DOMUtilsContext.selectorAll(element);
  1648.             }
  1649.             if (element == null) {
  1650.                 return;
  1651.             }
  1652.             if (isNodeList(element)) {
  1653.                 // 设置
  1654.                 element.forEach(($ele) => {
  1655.                     DOMUtilsContext.after($ele, content);
  1656.                 });
  1657.                 return;
  1658.             }
  1659.             if (typeof content === "string") {
  1660.                 element.insertAdjacentHTML("afterend", content);
  1661.             }
  1662.             else {
  1663.                 let $parent = element.parentElement;
  1664.                 let $nextSlibling = element.nextSibling;
  1665.                 if (!$parent || $nextSlibling) {
  1666.                     // 任意一个不行
  1667.                     element.after(content);
  1668.                 }
  1669.                 else {
  1670.                     element.parentElement.insertBefore(content, element.nextSibling);
  1671.                 }
  1672.             }
  1673.         }
  1674.         /**
  1675.          * 在元素前面添加兄弟元素或HTML字符串
  1676.          * @param element 目标元素
  1677.          * @param content 兄弟元素或HTML字符串
  1678.          * @example
  1679.          * // 元素a.xx前面添加一个元素
  1680.          * DOMUtils.before(document.querySelector("a.xx"),document.querySelector("b.xx"))
  1681.          * DOMUtils.before("a.xx","'<b class="xx"></b>")
  1682.          * */
  1683.         before(element, content) {
  1684.             let DOMUtilsContext = this;
  1685.             if (typeof element === "string") {
  1686.                 element = DOMUtilsContext.selectorAll(element);
  1687.             }
  1688.             if (element == null) {
  1689.                 return;
  1690.             }
  1691.             if (isNodeList(element)) {
  1692.                 // 设置
  1693.                 element.forEach(($ele) => {
  1694.                     DOMUtilsContext.before($ele, content);
  1695.                 });
  1696.                 return;
  1697.             }
  1698.             if (typeof content === "string") {
  1699.                 element.insertAdjacentHTML("beforebegin", content);
  1700.             }
  1701.             else {
  1702.                 let $parent = element.parentElement;
  1703.                 if (!$parent) {
  1704.                     element.before(content);
  1705.                 }
  1706.                 else {
  1707.                     $parent.insertBefore(content, element);
  1708.                 }
  1709.             }
  1710.         }
  1711.         /**
  1712.          * 移除元素
  1713.          * @param element 目标元素
  1714.          * @example
  1715.          * // 元素a.xx前面添加一个元素
  1716.          * DOMUtils.remove(document.querySelector("a.xx"))
  1717.          * DOMUtils.remove(document.querySelectorAll("a.xx"))
  1718.          * DOMUtils.remove("a.xx")
  1719.          * */
  1720.         remove(element) {
  1721.             let DOMUtilsContext = this;
  1722.             if (typeof element === "string") {
  1723.                 element = DOMUtilsContext.selectorAll(element);
  1724.             }
  1725.             if (element == null) {
  1726.                 return;
  1727.             }
  1728.             if (isNodeList(element)) {
  1729.                 element.forEach(($ele) => {
  1730.                     DOMUtilsContext.remove($ele);
  1731.                 });
  1732.                 return;
  1733.             }
  1734.             element.remove();
  1735.         }
  1736.         /**
  1737.          * 移除元素的所有子元素
  1738.          * @param element 目标元素
  1739.          * @example
  1740.          * // 移除元素a.xx元素的所有子元素
  1741.          * DOMUtils.empty(document.querySelector("a.xx"))
  1742.          * DOMUtils.empty("a.xx")
  1743.          * */
  1744.         empty(element) {
  1745.             let DOMUtilsContext = this;
  1746.             if (typeof element === "string") {
  1747.                 element = DOMUtilsContext.selectorAll(element);
  1748.             }
  1749.             if (element == null) {
  1750.                 return;
  1751.             }
  1752.             if (isNodeList(element)) {
  1753.                 // 设置
  1754.                 element.forEach(($ele) => {
  1755.                     DOMUtilsContext.empty($ele);
  1756.                 });
  1757.                 return;
  1758.             }
  1759.             element.innerHTML = "";
  1760.         }
  1761.         /**
  1762.          * 获取元素相对于文档的偏移坐标（加上文档的滚动条）
  1763.          * @param element 目标元素
  1764.          * @example
  1765.          * // 获取元素a.xx的对于文档的偏移坐标
  1766.          * DOMUtils.offset(document.querySelector("a.xx"))
  1767.          * DOMUtils.offset("a.xx")
  1768.          * > 0
  1769.          */
  1770.         offset(element) {
  1771.             let DOMUtilsContext = this;
  1772.             if (typeof element === "string") {
  1773.                 element = DOMUtilsContext.selector(element);
  1774.             }
  1775.             if (element == null) {
  1776.                 return;
  1777.             }
  1778.             let rect = element.getBoundingClientRect();
  1779.             return {
  1780.                 /** y轴偏移 */
  1781.                 top: rect.top + DOMUtilsContext.windowApi.globalThis.scrollY,
  1782.                 /** x轴偏移 */
  1783.                 left: rect.left + DOMUtilsContext.windowApi.globalThis.scrollX,
  1784.             };
  1785.         }
  1786.         width(element, isShow = false) {
  1787.             let DOMUtilsContext = this;
  1788.             if (typeof element === "string") {
  1789.                 element = DOMUtilsContext.selector(element);
  1790.             }
  1791.             if (element == null) {
  1792.                 return;
  1793.             }
  1794.             if (DOMUtilsCommonUtils.isWin(element)) {
  1795.                 return DOMUtilsContext.windowApi.window.document.documentElement
  1796.                     .clientWidth;
  1797.             }
  1798.             if (element.nodeType === 9) {
  1799.                 /* Document文档节点 */
  1800.                 element = element;
  1801.                 return Math.max(element.body.scrollWidth, element.documentElement.scrollWidth, element.body.offsetWidth, element.documentElement.offsetWidth, element.documentElement.clientWidth);
  1802.             }
  1803.             if (isShow ||
  1804.                 (!isShow && DOMUtilsCommonUtils.isShow(element))) {
  1805.                 /* 已显示 */
  1806.                 /* 不从style中获取对应的宽度，因为可能使用了class定义了width !important */
  1807.                 element = element;
  1808.                 /* 如果element.style.width为空  则从css里面获取是否定义了width信息如果定义了 则读取css里面定义的宽度width */
  1809.                 if (parseFloat(DOMUtilsCommonUtils.getStyleValue(element, "width").toString()) > 0) {
  1810.                     return parseFloat(DOMUtilsCommonUtils.getStyleValue(element, "width").toString());
  1811.                 }
  1812.                 /* 如果从css里获取到的值不是大于0  可能是auto 则通过offsetWidth来进行计算 */
  1813.                 if (element.offsetWidth > 0) {
  1814.                     let borderLeftWidth = DOMUtilsCommonUtils.getStyleValue(element, "borderLeftWidth");
  1815.                     let borderRightWidth = DOMUtilsCommonUtils.getStyleValue(element, "borderRightWidth");
  1816.                     let paddingLeft = DOMUtilsCommonUtils.getStyleValue(element, "paddingLeft");
  1817.                     let paddingRight = DOMUtilsCommonUtils.getStyleValue(element, "paddingRight");
  1818.                     let backHeight = parseFloat(element.offsetWidth.toString()) -
  1819.                         parseFloat(borderLeftWidth.toString()) -
  1820.                         parseFloat(borderRightWidth.toString()) -
  1821.                         parseFloat(paddingLeft.toString()) -
  1822.                         parseFloat(paddingRight.toString());
  1823.                     return parseFloat(backHeight.toString());
  1824.                 }
  1825.                 return 0;
  1826.             }
  1827.             else {
  1828.                 /* 未显示 */
  1829.                 element = element;
  1830.                 let { recovery } = DOMUtilsCommonUtils.showElement(element);
  1831.                 let width = DOMUtilsContext.width(element, true);
  1832.                 recovery();
  1833.                 return width;
  1834.             }
  1835.         }
  1836.         height(element, isShow = false) {
  1837.             let DOMUtilsContext = this;
  1838.             if (DOMUtilsCommonUtils.isWin(element)) {
  1839.                 return DOMUtilsContext.windowApi.window.document.documentElement
  1840.                     .clientHeight;
  1841.             }
  1842.             if (typeof element === "string") {
  1843.                 element = DOMUtilsContext.selector(element);
  1844.             }
  1845.             if (element == null) {
  1846.                 // @ts-ignore
  1847.                 return;
  1848.             }
  1849.             if (element.nodeType === 9) {
  1850.                 element = element;
  1851.                 /* Document文档节点 */
  1852.                 return Math.max(element.body.scrollHeight, element.documentElement.scrollHeight, element.body.offsetHeight, element.documentElement.offsetHeight, element.documentElement.clientHeight);
  1853.             }
  1854.             if (isShow ||
  1855.                 (!isShow && DOMUtilsCommonUtils.isShow(element))) {
  1856.                 element = element;
  1857.                 /* 已显示 */
  1858.                 /* 从style中获取对应的高度，因为可能使用了class定义了width !important */
  1859.                 /* 如果element.style.height为空  则从css里面获取是否定义了height信息如果定义了 则读取css里面定义的高度height */
  1860.                 if (parseFloat(DOMUtilsCommonUtils.getStyleValue(element, "height").toString()) > 0) {
  1861.                     return parseFloat(DOMUtilsCommonUtils.getStyleValue(element, "height").toString());
  1862.                 }
  1863.                 /* 如果从css里获取到的值不是大于0  可能是auto 则通过offsetHeight来进行计算 */
  1864.                 if (element.offsetHeight > 0) {
  1865.                     let borderTopWidth = DOMUtilsCommonUtils.getStyleValue(element, "borderTopWidth");
  1866.                     let borderBottomWidth = DOMUtilsCommonUtils.getStyleValue(element, "borderBottomWidth");
  1867.                     let paddingTop = DOMUtilsCommonUtils.getStyleValue(element, "paddingTop");
  1868.                     let paddingBottom = DOMUtilsCommonUtils.getStyleValue(element, "paddingBottom");
  1869.                     let backHeight = parseFloat(element.offsetHeight.toString()) -
  1870.                         parseFloat(borderTopWidth.toString()) -
  1871.                         parseFloat(borderBottomWidth.toString()) -
  1872.                         parseFloat(paddingTop.toString()) -
  1873.                         parseFloat(paddingBottom.toString());
  1874.                     return parseFloat(backHeight.toString());
  1875.                 }
  1876.                 return 0;
  1877.             }
  1878.             else {
  1879.                 /* 未显示 */
  1880.                 element = element;
  1881.                 let { recovery } = DOMUtilsCommonUtils.showElement(element);
  1882.                 let height = DOMUtilsContext.height(element, true);
  1883.                 recovery();
  1884.                 return height;
  1885.             }
  1886.         }
  1887.         outerWidth(element, isShow = false) {
  1888.             let DOMUtilsContext = this;
  1889.             if (DOMUtilsCommonUtils.isWin(element)) {
  1890.                 return DOMUtilsContext.windowApi.window.innerWidth;
  1891.             }
  1892.             if (typeof element === "string") {
  1893.                 element = DOMUtilsContext.selector(element);
  1894.             }
  1895.             if (element == null) {
  1896.                 // @ts-ignore
  1897.                 return;
  1898.             }
  1899.             element = element;
  1900.             if (isShow || (!isShow && DOMUtilsCommonUtils.isShow(element))) {
  1901.                 let style = DOMUtilsContext.windowApi.globalThis.getComputedStyle(element, null);
  1902.                 let marginLeft = DOMUtilsCommonUtils.getStyleValue(style, "marginLeft");
  1903.                 let marginRight = DOMUtilsCommonUtils.getStyleValue(style, "marginRight");
  1904.                 return element.offsetWidth + marginLeft + marginRight;
  1905.             }
  1906.             else {
  1907.                 let { recovery } = DOMUtilsCommonUtils.showElement(element);
  1908.                 let outerWidth = DOMUtilsContext.outerWidth(element, true);
  1909.                 recovery();
  1910.                 return outerWidth;
  1911.             }
  1912.         }
  1913.         outerHeight(element, isShow = false) {
  1914.             let DOMUtilsContext = this;
  1915.             if (DOMUtilsCommonUtils.isWin(element)) {
  1916.                 return DOMUtilsContext.windowApi.window.innerHeight;
  1917.             }
  1918.             if (typeof element === "string") {
  1919.                 element = DOMUtilsContext.selector(element);
  1920.             }
  1921.             if (element == null) {
  1922.                 // @ts-ignore
  1923.                 return;
  1924.             }
  1925.             element = element;
  1926.             if (isShow || (!isShow && DOMUtilsCommonUtils.isShow(element))) {
  1927.                 let style = DOMUtilsContext.windowApi.globalThis.getComputedStyle(element, null);
  1928.                 let marginTop = DOMUtilsCommonUtils.getStyleValue(style, "marginTop");
  1929.                 let marginBottom = DOMUtilsCommonUtils.getStyleValue(style, "marginBottom");
  1930.                 return element.offsetHeight + marginTop + marginBottom;
  1931.             }
  1932.             else {
  1933.                 let { recovery } = DOMUtilsCommonUtils.showElement(element);
  1934.                 let outerHeight = DOMUtilsContext.outerHeight(element, true);
  1935.                 recovery();
  1936.                 return outerHeight;
  1937.             }
  1938.         }
  1939.         /**
  1940.          * 在一定时间内改变元素的样式属性，实现动画效果
  1941.          * @param element 需要进行动画的元素
  1942.          * @param styles 动画结束时元素的样式属性
  1943.          * @param duration 动画持续时间，单位为毫秒
  1944.          * @param callback 动画结束后执行的函数
  1945.          * @example
  1946.          * // 监听元素a.xx的从显示变为隐藏
  1947.          * DOMUtils.animate(document.querySelector("a.xx"),{ top:100},1000,function(){
  1948.          *   console.log("已往上位移100px")
  1949.          * })
  1950.          */
  1951.         animate(element, styles, duration = 1000, callback = null) {
  1952.             let DOMUtilsContext = this;
  1953.             if (typeof element === "string") {
  1954.                 element = DOMUtilsContext.selectorAll(element);
  1955.             }
  1956.             if (element == null) {
  1957.                 return;
  1958.             }
  1959.             if (isNodeList(element)) {
  1960.                 // 设置
  1961.                 element.forEach(($ele) => {
  1962.                     DOMUtilsContext.animate($ele, styles, duration, callback);
  1963.                 });
  1964.                 return;
  1965.             }
  1966.             if (typeof duration !== "number" || duration <= 0) {
  1967.                 throw new TypeError("duration must be a positive number");
  1968.             }
  1969.             if (typeof callback !== "function" && callback !== void 0) {
  1970.                 throw new TypeError("callback must be a function or null");
  1971.             }
  1972.             if (typeof styles !== "object" || styles === void 0) {
  1973.                 throw new TypeError("styles must be an object");
  1974.             }
  1975.             if (Object.keys(styles).length === 0) {
  1976.                 throw new Error("styles must contain at least one property");
  1977.             }
  1978.             let start = performance.now();
  1979.             let from = {};
  1980.             let to = {};
  1981.             for (let prop in styles) {
  1982.                 from[prop] =
  1983.                     element.style[prop] ||
  1984.                         DOMUtilsContext.windowApi.globalThis.getComputedStyle(element)[prop];
  1985.                 to[prop] = styles[prop];
  1986.             }
  1987.             let timer = setInterval(function () {
  1988.                 let timePassed = performance.now() - start;
  1989.                 let progress = timePassed / duration;
  1990.                 if (progress > 1) {
  1991.                     progress = 1;
  1992.                 }
  1993.                 for (let prop in styles) {
  1994.                     element.style[prop] =
  1995.                         from[prop] + (to[prop] - from[prop]) * progress + "px";
  1996.                 }
  1997.                 if (progress === 1) {
  1998.                     clearInterval(timer);
  1999.                     if (callback) {
  2000.                         callback();
  2001.                     }
  2002.                 }
  2003.             }, 10);
  2004.         }
  2005.         /**
  2006.          * 将一个元素包裹在指定的HTML元素中
  2007.          * @param element 要包裹的元素
  2008.          * @param wrapperHTML 要包裹的HTML元素的字符串表示形式
  2009.          * @example
  2010.          * // 将a.xx元素外面包裹一层div
  2011.          * DOMUtils.wrap(document.querySelector("a.xx"),"<div></div>")
  2012.          */
  2013.         wrap(element, wrapperHTML) {
  2014.             let DOMUtilsContext = this;
  2015.             if (typeof element === "string") {
  2016.                 element = DOMUtilsContext.selectorAll(element);
  2017.             }
  2018.             if (element == null) {
  2019.                 return;
  2020.             }
  2021.             if (isNodeList(element)) {
  2022.                 // 设置
  2023.                 element.forEach(($ele) => {
  2024.                     DOMUtilsContext.wrap($ele, wrapperHTML);
  2025.                 });
  2026.                 return;
  2027.             }
  2028.             element = element;
  2029.             // 创建一个新的div元素，并将wrapperHTML作为其innerHTML
  2030.             let wrapper = DOMUtilsContext.windowApi.document.createElement("div");
  2031.             wrapper.innerHTML = wrapperHTML;
  2032.             let wrapperFirstChild = wrapper.firstChild;
  2033.             // 将要包裹的元素插入目标元素前面
  2034.             let parentElement = element.parentElement;
  2035.             parentElement.insertBefore(wrapperFirstChild, element);
  2036.             // 将要包裹的元素移动到wrapper中
  2037.             wrapperFirstChild.appendChild(element);
  2038.         }
  2039.         prev(element) {
  2040.             let DOMUtilsContext = this;
  2041.             if (typeof element === "string") {
  2042.                 element = DOMUtilsContext.selector(element);
  2043.             }
  2044.             if (element == null) {
  2045.                 return;
  2046.             }
  2047.             return element.previousElementSibling;
  2048.         }
  2049.         next(element) {
  2050.             let DOMUtilsContext = this;
  2051.             if (typeof element === "string") {
  2052.                 element = DOMUtilsContext.selector(element);
  2053.             }
  2054.             if (element == null) {
  2055.                 return;
  2056.             }
  2057.             return element.nextElementSibling;
  2058.         }
  2059.         /**
  2060.          * 取消挂载在window下的DOMUtils并返回DOMUtils
  2061.          * @example
  2062.          * let DOMUtils = window.DOMUtils.noConflict()
  2063.          */
  2064.         noConflict() {
  2065.             let DOMUtilsContext = this;
  2066.             if (DOMUtilsContext.windowApi.window.DOMUtils) {
  2067.                 DOMUtilsCommonUtils.delete(window, "DOMUtils");
  2068.             }
  2069.             DOMUtilsContext.windowApi.window.DOMUtils = this;
  2070.             return this;
  2071.         }
  2072.         siblings(element) {
  2073.             let DOMUtilsContext = this;
  2074.             if (typeof element === "string") {
  2075.                 element = DOMUtilsContext.selector(element);
  2076.             }
  2077.             if (element == null) {
  2078.                 return;
  2079.             }
  2080.             return Array.from(element.parentElement
  2081.                 .children).filter((child) => child !== element);
  2082.         }
  2083.         /**
  2084.          * 获取当前元素的父元素
  2085.          * @param element 当前元素
  2086.          * @returns 父元素
  2087.          * @example
  2088.          * // 获取a.xx元素的父元素
  2089.          * DOMUtils.parent(document.querySelector("a.xx"))
  2090.          * DOMUtils.parent("a.xx")
  2091.          * > <div ...>....</div>
  2092.          */
  2093.         parent(element) {
  2094.             let DOMUtilsContext = this;
  2095.             if (typeof element === "string") {
  2096.                 element = DOMUtilsContext.selector(element);
  2097.             }
  2098.             if (element == null) {
  2099.                 return;
  2100.             }
  2101.             if (isNodeList(element)) {
  2102.                 let resultArray = [];
  2103.                 element.forEach(($ele) => {
  2104.                     resultArray.push(DOMUtilsContext.parent($ele));
  2105.                 });
  2106.                 return resultArray;
  2107.             }
  2108.             else {
  2109.                 return element.parentElement;
  2110.             }
  2111.         }
  2112.         parseHTML(html, useParser = false, isComplete = false) {
  2113.             let DOMUtilsContext = this;
  2114.             // 去除html前后的空格
  2115.             html = html.trim();
  2116.             function parseHTMLByDOMParser() {
  2117.                 let parser = new DOMParser();
  2118.                 if (isComplete) {
  2119.                     return parser.parseFromString(html, "text/html");
  2120.                 }
  2121.                 else {
  2122.                     return parser.parseFromString(html, "text/html").body.firstChild;
  2123.                 }
  2124.             }
  2125.             function parseHTMLByCreateDom() {
  2126.                 let tempDIV = DOMUtilsContext.windowApi.document.createElement("div");
  2127.                 tempDIV.innerHTML = html;
  2128.                 if (isComplete) {
  2129.                     return tempDIV;
  2130.                 }
  2131.                 else {
  2132.                     return tempDIV.firstChild;
  2133.                 }
  2134.             }
  2135.             if (useParser) {
  2136.                 return parseHTMLByDOMParser();
  2137.             }
  2138.             else {
  2139.                 return parseHTMLByCreateDom();
  2140.             }
  2141.         }
  2142.         /**
  2143.          * 序列化表单元素
  2144.          * @param $form 表单元素
  2145.          * @example
  2146.          * DOMUtils.serialize(document.querySelector("form"))
  2147.          * > xxx=xxx&aaa=
  2148.          */
  2149.         serialize($form) {
  2150.             const elements = $form.elements;
  2151.             let serializedArray = [];
  2152.             for (let i = 0; i < elements.length; i++) {
  2153.                 const element = elements[i];
  2154.                 if (element.name &&
  2155.                     !element.disabled &&
  2156.                     (element.checked ||
  2157.                         [
  2158.                             "text",
  2159.                             "hidden",
  2160.                             "password",
  2161.                             "textarea",
  2162.                             "select-one",
  2163.                             "select-multiple",
  2164.                         ].includes(element.type))) {
  2165.                     if (element.type === "select-multiple") {
  2166.                         for (let j = 0; j < element.options.length; j++) {
  2167.                             if (element.options[j].selected) {
  2168.                                 serializedArray.push({
  2169.                                     name: element.name,
  2170.                                     value: element.options[j].value,
  2171.                                 });
  2172.                             }
  2173.                         }
  2174.                     }
  2175.                     else {
  2176.                         serializedArray.push({ name: element.name, value: element.value });
  2177.                     }
  2178.                 }
  2179.             }
  2180.             return serializedArray
  2181.                 .map((item) => `${encodeURIComponent(item.name)}=${encodeURIComponent(item.value)}`)
  2182.                 .join("&");
  2183.         }
  2184.         /**
  2185.          * 显示元素
  2186.          * @param target 当前元素
  2187.          * @param checkVisiblie 是否检测元素是否显示
  2188.          * + true （默认）如果检测到还未显示，则强制使用display: unset !important;
  2189.          * + false 不检测，直接设置display属性为空
  2190.          * @example
  2191.          * // 显示a.xx元素
  2192.          * DOMUtils.show(document.querySelector("a.xx"))
  2193.          * DOMUtils.show(document.querySelectorAll("a.xx"))
  2194.          * DOMUtils.show("a.xx")
  2195.          */
  2196.         show(target, checkVisiblie = true) {
  2197.             let DOMUtilsContext = this;
  2198.             if (target == null) {
  2199.                 return;
  2200.             }
  2201.             if (typeof target === "string") {
  2202.                 target = DOMUtilsContext.selectorAll(target);
  2203.             }
  2204.             if (target instanceof NodeList || target instanceof Array) {
  2205.                 target = target;
  2206.                 for (const element of target) {
  2207.                     DOMUtilsContext.show(element, checkVisiblie);
  2208.                 }
  2209.             }
  2210.             else {
  2211.                 target = target;
  2212.                 target.style.display = "";
  2213.                 if (checkVisiblie) {
  2214.                     if (!DOMUtilsCommonUtils.isShow(target)) {
  2215.                         /* 仍然是不显示，尝试使用强覆盖 */
  2216.                         target.style.setProperty("display", "unset", "important");
  2217.                     }
  2218.                 }
  2219.             }
  2220.         }
  2221.         /**
  2222.          * 隐藏元素
  2223.          * @param target 当前元素
  2224.          * @param checkVisiblie 是否检测元素是否显示
  2225.          * + true （默认）如果检测到显示，则强制使用display: none !important;
  2226.          * + false 不检测，直接设置display属性为none
  2227.          * @example
  2228.          * // 隐藏a.xx元素
  2229.          * DOMUtils.hide(document.querySelector("a.xx"))
  2230.          * DOMUtils.hide(document.querySelectorAll("a.xx"))
  2231.          * DOMUtils.hide("a.xx")
  2232.          */
  2233.         hide(target, checkVisiblie = true) {
  2234.             let DOMUtilsContext = this;
  2235.             if (target == null) {
  2236.                 return;
  2237.             }
  2238.             if (typeof target === "string") {
  2239.                 target = DOMUtilsContext.selectorAll(target);
  2240.             }
  2241.             if (target instanceof NodeList || target instanceof Array) {
  2242.                 target = target;
  2243.                 for (const element of target) {
  2244.                     DOMUtilsContext.hide(element, checkVisiblie);
  2245.                 }
  2246.             }
  2247.             else {
  2248.                 target = target;
  2249.                 target.style.display = "none";
  2250.                 if (checkVisiblie) {
  2251.                     if (DOMUtilsCommonUtils.isShow(target)) {
  2252.                         /* 仍然是显示，尝试使用强覆盖 */
  2253.                         target.style.setProperty("display", "none", "important");
  2254.                     }
  2255.                 }
  2256.             }
  2257.         }
  2258.         /**
  2259.          * 淡入元素
  2260.          * @param element 当前元素
  2261.          * @param duration 动画持续时间（毫秒），默认400毫秒
  2262.          * @param callback 动画结束的回调
  2263.          * @example
  2264.          * // 元素a.xx淡入
  2265.          * DOMUtils.fadeIn(document.querySelector("a.xx"),2500,()=>{
  2266.          *   console.log("淡入完毕");
  2267.          * })
  2268.          * DOMUtils.fadeIn("a.xx",undefined,()=>{
  2269.          *   console.log("淡入完毕");
  2270.          * })
  2271.          */
  2272.         fadeIn(element, duration = 400, callback) {
  2273.             if (element == null) {
  2274.                 return;
  2275.             }
  2276.             let DOMUtilsContext = this;
  2277.             if (typeof element === "string") {
  2278.                 element = DOMUtilsContext.selectorAll(element);
  2279.             }
  2280.             if (isNodeList(element)) {
  2281.                 // 设置
  2282.                 element.forEach(($ele) => {
  2283.                     DOMUtilsContext.fadeIn($ele, duration, callback);
  2284.                 });
  2285.                 return;
  2286.             }
  2287.             element.style.opacity = "0";
  2288.             element.style.display = "";
  2289.             let start = null;
  2290.             let timer = null;
  2291.             function step(timestamp) {
  2292.                 if (!start)
  2293.                     start = timestamp;
  2294.                 let progress = timestamp - start;
  2295.                 element = element;
  2296.                 element.style.opacity = Math.min(progress / duration, 1).toString();
  2297.                 if (progress < duration) {
  2298.                     DOMUtilsContext.windowApi.window.requestAnimationFrame(step);
  2299.                 }
  2300.                 else {
  2301.                     if (callback && typeof callback === "function") {
  2302.                         callback();
  2303.                     }
  2304.                     DOMUtilsContext.windowApi.window.cancelAnimationFrame(timer);
  2305.                 }
  2306.             }
  2307.             timer = DOMUtilsContext.windowApi.window.requestAnimationFrame(step);
  2308.         }
  2309.         /**
  2310.          * 淡出元素
  2311.          * @param element 当前元素
  2312.          * @param duration 动画持续时间（毫秒），默认400毫秒
  2313.          * @param callback 动画结束的回调
  2314.          * @example
  2315.          * // 元素a.xx淡出
  2316.          * DOMUtils.fadeOut(document.querySelector("a.xx"),2500,()=>{
  2317.          *   console.log("淡出完毕");
  2318.          * })
  2319.          * DOMUtils.fadeOut("a.xx",undefined,()=>{
  2320.          *   console.log("淡出完毕");
  2321.          * })
  2322.          */
  2323.         fadeOut(element, duration = 400, callback) {
  2324.             let DOMUtilsContext = this;
  2325.             if (element == null) {
  2326.                 return;
  2327.             }
  2328.             if (typeof element === "string") {
  2329.                 element = DOMUtilsContext.selectorAll(element);
  2330.             }
  2331.             if (isNodeList(element)) {
  2332.                 // 设置
  2333.                 element.forEach(($ele) => {
  2334.                     DOMUtilsContext.fadeOut($ele, duration, callback);
  2335.                 });
  2336.                 return;
  2337.             }
  2338.             element.style.opacity = "1";
  2339.             let start = null;
  2340.             let timer = null;
  2341.             function step(timestamp) {
  2342.                 if (!start)
  2343.                     start = timestamp;
  2344.                 let progress = timestamp - start;
  2345.                 element = element;
  2346.                 element.style.opacity = Math.max(1 - progress / duration, 0).toString();
  2347.                 if (progress < duration) {
  2348.                     DOMUtilsContext.windowApi.window.requestAnimationFrame(step);
  2349.                 }
  2350.                 else {
  2351.                     element.style.display = "none";
  2352.                     if (typeof callback === "function") {
  2353.                         callback();
  2354.                     }
  2355.                     DOMUtilsContext.windowApi.window.cancelAnimationFrame(timer);
  2356.                 }
  2357.             }
  2358.             timer = DOMUtilsContext.windowApi.window.requestAnimationFrame(step);
  2359.         }
  2360.         /**
  2361.          * 切换元素的显示和隐藏状态
  2362.          * @param element 当前元素
  2363.          * @param checkVisiblie 是否检测元素是否显示
  2364.          * @example
  2365.          * // 如果元素a.xx当前是隐藏，则显示，如果是显示，则隐藏
  2366.          * DOMUtils.toggle(document.querySelector("a.xx"))
  2367.          * DOMUtils.toggle("a.xx")
  2368.          */
  2369.         toggle(element, checkVisiblie) {
  2370.             let DOMUtilsContext = this;
  2371.             if (typeof element === "string") {
  2372.                 element = DOMUtilsContext.selectorAll(element);
  2373.             }
  2374.             if (element == null) {
  2375.                 return;
  2376.             }
  2377.             if (isNodeList(element)) {
  2378.                 // 设置
  2379.                 element.forEach(($ele) => {
  2380.                     DOMUtilsContext.toggle($ele);
  2381.                 });
  2382.                 return;
  2383.             }
  2384.             if (DOMUtilsContext.windowApi.globalThis
  2385.                 .getComputedStyle(element)
  2386.                 .getPropertyValue("display") === "none") {
  2387.                 DOMUtilsContext.show(element, checkVisiblie);
  2388.             }
  2389.             else {
  2390.                 DOMUtilsContext.hide(element, checkVisiblie);
  2391.             }
  2392.         }
  2393.         /**
  2394.          * 创建一个新的DOMUtils实例
  2395.          * @param option
  2396.          * @returns
  2397.          */
  2398.         createDOMUtils(option) {
  2399.             return new DOMUtils(option);
  2400.         }
  2401.         /**
  2402.          * 获取文字的位置信息
  2403.          * @param $input 输入框
  2404.          * @param selectionStart 起始位置
  2405.          * @param selectionEnd 结束位置
  2406.          * @example
  2407.          * DOMUtils.getTextBoundingRect(document.querySelector("input"));
  2408.          */
  2409.         getTextBoundingRect($input, selectionStart, selectionEnd) {
  2410.             let DOMUtilsContext = this;
  2411.             // Basic parameter validation
  2412.             if (!$input || !("value" in $input))
  2413.                 return $input;
  2414.             if (selectionStart == null) {
  2415.                 selectionStart = $input.selectionStart || 0;
  2416.             }
  2417.             if (selectionEnd == null) {
  2418.                 selectionEnd = $input.selectionEnd || 0;
  2419.             }
  2420.             if (typeof selectionStart == "string")
  2421.                 selectionStart = parseFloat(selectionStart);
  2422.             if (typeof selectionStart != "number" || isNaN(selectionStart)) {
  2423.                 selectionStart = 0;
  2424.             }
  2425.             if (selectionStart < 0)
  2426.                 selectionStart = 0;
  2427.             else
  2428.                 selectionStart = Math.min($input.value.length, selectionStart);
  2429.             if (typeof selectionEnd == "string")
  2430.                 selectionEnd = parseFloat(selectionEnd);
  2431.             if (typeof selectionEnd != "number" ||
  2432.                 isNaN(selectionEnd) ||
  2433.                 selectionEnd < selectionStart) {
  2434.                 selectionEnd = selectionStart;
  2435.             }
  2436.             if (selectionEnd < 0)
  2437.                 selectionEnd = 0;
  2438.             else
  2439.                 selectionEnd = Math.min($input.value.length, selectionEnd);
  2440.             // If available (thus IE), use the createTextRange method
  2441.             // @ts-ignore
  2442.             if (typeof $input.createTextRange == "function") {
  2443.                 let range = $input.createTextRange();
  2444.                 range.collapse(true);
  2445.                 range.moveStart("character", selectionStart);
  2446.                 range.moveEnd("character", selectionEnd - selectionStart);
  2447.                 return range.getBoundingClientRect();
  2448.             }
  2449.             // createTextRange is not supported, create a fake text range
  2450.             let offset = getInputOffset(), topPos = offset.top, leftPos = offset.left, width = getInputCSS("width", true), height = getInputCSS("height", true);
  2451.             // Styles to simulate a node in an input field
  2452.             let cssDefaultStyles = "white-space:pre;padding:0;margin:0;", listOfModifiers = [
  2453.                 "direction",
  2454.                 "font-family",
  2455.                 "font-size",
  2456.                 "font-size-adjust",
  2457.                 "font-variant",
  2458.                 "font-weight",
  2459.                 "font-style",
  2460.                 "letter-spacing",
  2461.                 "line-height",
  2462.                 "text-align",
  2463.                 "text-indent",
  2464.                 "text-transform",
  2465.                 "word-wrap",
  2466.                 "word-spacing",
  2467.             ];
  2468.             topPos += getInputCSS("padding-top", true);
  2469.             topPos += getInputCSS("border-top-width", true);
  2470.             leftPos += getInputCSS("padding-left", true);
  2471.             leftPos += getInputCSS("border-left-width", true);
  2472.             leftPos += 1; //Seems to be necessary
  2473.             for (let index = 0; index < listOfModifiers.length; index++) {
  2474.                 let property = listOfModifiers[index];
  2475.                 // @ts-ignore
  2476.                 cssDefaultStyles += property + ":" + getInputCSS(property) + ";";
  2477.             }
  2478.             // End of CSS variable checks
  2479.             // 不能为空，不然获取不到高度
  2480.             let text = $input.value || "G", textLen = text.length, fakeClone = DOMUtilsContext.windowApi.document.createElement("div");
  2481.             if (selectionStart > 0)
  2482.                 appendPart(0, selectionStart);
  2483.             var fakeRange = appendPart(selectionStart, selectionEnd);
  2484.             if (textLen > selectionEnd)
  2485.                 appendPart(selectionEnd, textLen);
  2486.             // Styles to inherit the font styles of the element
  2487.             fakeClone.style.cssText = cssDefaultStyles;
  2488.             // Styles to position the text node at the desired position
  2489.             fakeClone.style.position = "absolute";
  2490.             fakeClone.style.top = topPos + "px";
  2491.             fakeClone.style.left = leftPos + "px";
  2492.             fakeClone.style.width = width + "px";
  2493.             fakeClone.style.height = height + "px";
  2494.             DOMUtilsContext.windowApi.document.body.appendChild(fakeClone);
  2495.             var returnValue = fakeRange.getBoundingClientRect(); //Get rect
  2496.             fakeClone?.parentNode?.removeChild(fakeClone); //Remove temp
  2497.             return returnValue;
  2498.             // Local functions for readability of the previous code
  2499.             /**
  2500.              *
  2501.              * @param start
  2502.              * @param end
  2503.              * @returns
  2504.              */
  2505.             function appendPart(start, end) {
  2506.                 var span = DOMUtilsContext.windowApi.document.createElement("span");
  2507.                 span.style.cssText = cssDefaultStyles; //Force styles to prevent unexpected results
  2508.                 span.textContent = text.substring(start, end);
  2509.                 fakeClone.appendChild(span);
  2510.                 return span;
  2511.             }
  2512.             // Computing offset position
  2513.             function getInputOffset() {
  2514.                 let body = DOMUtilsContext.windowApi.document.body, win = DOMUtilsContext.windowApi.document.defaultView, docElem = DOMUtilsContext.windowApi.document.documentElement, $box = DOMUtilsContext.windowApi.document.createElement("div");
  2515.                 $box.style.paddingLeft = $box.style.width = "1px";
  2516.                 body.appendChild($box);
  2517.                 var isBoxModel = $box.offsetWidth == 2;
  2518.                 body.removeChild($box);
  2519.                 let $boxRect = $input.getBoundingClientRect();
  2520.                 var clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0, scrollTop = win.pageYOffset ||
  2521.                     (isBoxModel && docElem.scrollTop) ||
  2522.                     body.scrollTop, scrollLeft = win.pageXOffset ||
  2523.                     (isBoxModel && docElem.scrollLeft) ||
  2524.                     body.scrollLeft;
  2525.                 return {
  2526.                     top: $boxRect.top + scrollTop - clientTop,
  2527.                     left: $boxRect.left + scrollLeft - clientLeft,
  2528.                 };
  2529.             }
  2530.             /**
  2531.              *
  2532.              * @param prop
  2533.              * @param isNumber
  2534.              * @returns
  2535.              */
  2536.             function getInputCSS(prop, isNumber) {
  2537.                 var val = DOMUtilsContext.windowApi.document
  2538.                     .defaultView.getComputedStyle($input, null)
  2539.                     .getPropertyValue(prop);
  2540.                 return isNumber ? parseFloat(val) : val;
  2541.             }
  2542.         }
  2543.     }
  2544.     let domUtils = new DOMUtils();
  2545.  
  2546.     return domUtils;
  2547.  
  2548. }));
  2549. //# sourceMappingURL=index.umd.js.map