☰

DOMUtils

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

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