@rpascene/shared 0.30.8

package/dist/lib/extractor/customLocator.js

@@ -0,0 +1,698 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getContainerPath: ()=>getContainerLocatorData,
+    getElements: ()=>getManyElementByLocators,
+    getFullLocator: ()=>getFullLocator,
+    getLocatorUntilFieldid: ()=>getLocatorUntilFieldid,
+    getLocators: ()=>getLocators,
+    getShadowRootContainerStack: ()=>getShadowRootContainerStack,
+    getUniqueElement: ()=>getOneElementByLocators
+});
+const attributeValue = (value)=>{
+    if (!value) return '';
+    if (value.indexOf("'") < 0) return "'" + value + "'";
+    {
+        if (value.indexOf('"') < 0) return '"' + value + '"';
+        let result = 'concat(';
+        let part = '';
+        let didReachEndOfValue = false;
+        while(!didReachEndOfValue){
+            let apos = value.indexOf("'");
+            let quot = value.indexOf('"');
+            if (apos < 0) {
+                result += "'" + value + "'";
+                didReachEndOfValue = true;
+                break;
+            }
+            if (quot < 0) {
+                result += '"' + value + '"';
+                didReachEndOfValue = true;
+                break;
+            }
+            if (quot < apos) {
+                part = value.substring(0, apos);
+                result += "'" + part + "'";
+                value = value.substring(part.length);
+            } else {
+                part = value.substring(0, quot);
+                result += '"' + part + '"';
+                value = value.substring(part.length);
+            }
+            result += ',';
+        }
+        result += ')';
+        return result;
+    }
+};
+const verifyXPath = (xpath, dom)=>{
+    const root = dom.getRootNode();
+    if (isShadowRoot(root)) return null;
+    if (xpath) {
+        const doms = getElementsByLocator({
+            type: 'xpath',
+            value: xpath
+        });
+        if (1 === doms.length && doms[0] === dom) return xpath;
+    }
+    return null;
+};
+const verifySelector = (selector, dom, type = 'querySelect')=>{
+    const root = dom.getRootNode();
+    const doms = getElementsByLocator({
+        type,
+        value: selector
+    }, root);
+    if (1 === doms.length && doms[0] === dom) return selector;
+    return null;
+};
+const isHostElement = (dom)=>{
+    var _dom_shadowRoot;
+    return (null == (_dom_shadowRoot = dom.shadowRoot) ? void 0 : _dom_shadowRoot.nodeName) === '#document-fragment';
+};
+const isShadowRoot = (node)=>'#document-fragment' === node.nodeName;
+const getRelativeSelector = (dom, useFieldId = true)=>{
+    try {
+        const id = dom.id;
+        const fieldid = dom.getAttribute('fieldid');
+        const children = Array.from(dom.parentNode.childNodes).filter(($el)=>1 === $el.nodeType);
+        const index = children.findIndex((item)=>item === dom) + 1;
+        let extra = '';
+        if (useFieldId && fieldid) {
+            const sameAttrChildren = children.filter(($el)=>$el.tagName === dom.tagName && $el.getAttribute('fieldid') === fieldid);
+            extra = 1 === sameAttrChildren.length ? `[fieldid='${fieldid}']` : `[fieldid='${fieldid}']:nth-child(${index})`;
+        } else if (!useFieldId && id) {
+            const sameAttrChildren = children.filter(($el)=>$el.tagName === dom.tagName && $el.id === id);
+            extra = 1 === sameAttrChildren.length ? `[id='${id}']` : `[id='${id}']:nth-child(${index})`;
+        } else {
+            const sameTagChildren = children.filter(($el)=>$el.tagName === dom.tagName);
+            extra = 1 === sameTagChildren.length ? '' : `:nth-child(${index})`;
+        }
+        return dom.tagName.toLowerCase() + extra;
+    } catch (error) {
+        console.error(error);
+        return '';
+    }
+};
+const getRelativeXpath = (dom, useFieldId = true)=>{
+    try {
+        if (!dom || 1 !== dom.nodeType) return '';
+        if ('OPTION' === dom.tagName) return '';
+        const root = dom.getRootNode();
+        if (isShadowRoot(root)) return '';
+        const id = dom.id;
+        const fieldid = dom.getAttribute('fieldid');
+        const children = Array.from(dom.parentNode.childNodes).filter(($el)=>1 === $el.nodeType);
+        const tagName = dom.tagName.toLowerCase();
+        const isDescendantOfSVG = null !== dom.closest('svg');
+        let extra = '';
+        if (useFieldId && fieldid) {
+            const sameAttrChildren = children.filter(($el)=>$el.tagName === dom.tagName && $el.getAttribute('fieldid') === fieldid);
+            if (isDescendantOfSVG) {
+                if (1 === sameAttrChildren.length) return `/*[name()='${tagName}' and @fieldid='${fieldid}']`;
+                const index = sameAttrChildren.findIndex((item)=>item === dom) + 1;
+                return `/*[name()='${tagName}' and @fieldid='${fieldid}'][${index}]`;
+            }
+            if (1 === sameAttrChildren.length) extra = `[@fieldid='${fieldid}']`;
+            else {
+                const index = sameAttrChildren.findIndex((item)=>item === dom) + 1;
+                extra = `[@fieldid='${fieldid}'][${index}]`;
+            }
+        } else if (!useFieldId && id) {
+            const sameAttrChildren = children.filter(($el)=>$el.tagName === dom.tagName && $el.id === id);
+            if (isDescendantOfSVG) {
+                if (1 === sameAttrChildren.length) return `/*[name()='${tagName}' and @id='${id}']`;
+                const index = sameAttrChildren.findIndex((item)=>item === dom) + 1;
+                return `/*[name()='${tagName}' and @id='${id}'][${index}]`;
+            }
+            if (1 === sameAttrChildren.length) extra = `[@id='${id}']`;
+            else {
+                const index = sameAttrChildren.findIndex((item)=>item === dom) + 1;
+                extra = `[@id='${id}'][${index}]`;
+            }
+        } else {
+            const sameAttrChildren = children.filter(($el)=>$el.tagName === dom.tagName);
+            if (isDescendantOfSVG) {
+                if (1 === sameAttrChildren.length) return `/*[name()='${tagName}']`;
+                const index = sameAttrChildren.findIndex((item)=>item === dom) + 1;
+                return `/*[name()='${tagName}'][${index}]`;
+            }
+            if (1 === sameAttrChildren.length) extra = '';
+            else {
+                const index = sameAttrChildren.findIndex((item)=>item === dom) + 1;
+                extra = `[${index}]`;
+            }
+        }
+        return '/' + dom.tagName.toLowerCase() + extra;
+    } catch (error) {
+        console.error(error);
+        return '';
+    }
+};
+const getElementsByXPath = (xpath, contextNode = document)=>{
+    try {
+        if ('#document' !== contextNode.nodeName && '#document' !== contextNode.getRootNode().nodeName) return null;
+        const snapshot = document.evaluate(xpath, contextNode, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+        const list = [];
+        for(let i = 0, len = snapshot.snapshotLength; i < len; i++)list.push(snapshot.snapshotItem(i));
+        return list;
+    } catch (error) {
+        console.error(error);
+        return [];
+    }
+};
+const getElementsByLocator = (locator, docOrHost = document)=>{
+    try {
+        const { type, value } = locator;
+        let eles = [];
+        const contextNode = docOrHost.shadowRoot || docOrHost;
+        if ('id' === type) eles = contextNode.querySelectorAll(`*[id='${value}']`);
+        else if ('className' === type) eles = contextNode.querySelectorAll(`*[class='${value}']`);
+        else if ('name' === type) eles = contextNode.querySelectorAll(`*[name='${value}']`);
+        else if ('querySelect' === type) eles = contextNode.querySelectorAll(value);
+        else if ('xpath' === type) eles = getElementsByXPath(value, contextNode) || [];
+        return Array.from(eles);
+    } catch (error) {
+        console.error(error);
+        return [];
+    }
+};
+const getBaseSelectors = (dom)=>{
+    const locators = [];
+    const { id, name, classList } = dom;
+    if (id) locators.push({
+        type: 'id',
+        value: id
+    });
+    if (name) locators.push({
+        type: 'name',
+        value: name
+    });
+    return locators;
+};
+const getLocatorUntilFieldid = (dom, type)=>{
+    const getXpathUntilFieldid = (dom)=>{
+        try {
+            if (!dom || 1 !== dom.nodeType) return '';
+            const useFieldId = !!document.querySelector('*[fieldid]');
+            const relativeXpath = getRelativeXpath(dom, useFieldId);
+            if (useFieldId && relativeXpath.includes('textCol|')) return '';
+            if (/\[@/g.test(relativeXpath)) return '/' + relativeXpath;
+            return getXpathUntilFieldid(dom.parentNode) + relativeXpath;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    const getSelectorUntilFieldid = (dom)=>{
+        try {
+            if (!dom || 1 !== dom.nodeType) return '';
+            const useFieldId = !!document.querySelector('*[fieldid]');
+            const relativeSelector = getRelativeSelector(dom, useFieldId);
+            if (useFieldId && relativeSelector.includes('textCol|')) return '';
+            if (relativeSelector.includes('id=') || relativeSelector.includes('fieldid=')) return relativeSelector;
+            const parentSelector = getSelectorUntilFieldid(dom.parentNode);
+            return parentSelector ? parentSelector + ' > ' + relativeSelector : relativeSelector;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    if ('xpath' === type) return {
+        type: 'xpath',
+        value: getXpathUntilFieldid(dom)
+    };
+    if ('querySelect' === type) return {
+        type: 'querySelect',
+        value: getSelectorUntilFieldid(dom)
+    };
+    const value = getXpathUntilFieldid(dom);
+    if (value) return {
+        type: 'xpath',
+        value
+    };
+    return {
+        type: 'querySelect',
+        value: getSelectorUntilFieldid(dom)
+    };
+};
+const getFullLocator = (dom, type)=>{
+    const getFullXpath = (dom)=>{
+        try {
+            if (!dom || 1 !== dom.nodeType) return '';
+            if ('OPTION' === dom.tagName) return '';
+            const root = dom.getRootNode();
+            if ('#document-fragment' === root.nodeName) return '';
+            if ('BODY' === dom.tagName) return '/html/body';
+            if ('HTML' === dom.tagName) return '/html';
+            const sameTagChildren = Array.from(dom.parentNode.childNodes).filter(($el)=>1 === $el.nodeType && $el.tagName === dom.tagName);
+            let extra = '';
+            if (1 === sameTagChildren.length) extra = '';
+            else {
+                const index = sameTagChildren.findIndex((item)=>item === dom) + 1;
+                extra = `[${index}]`;
+            }
+            const lowerTagName = dom.tagName.toLowerCase();
+            const isDescendantOfSVG = null !== dom.closest('svg');
+            const me = (isDescendantOfSVG ? `*[name()='${lowerTagName}']` : lowerTagName) + extra;
+            return getFullXpath(dom.parentNode) + '/' + me;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    const getFullSelector = (dom)=>{
+        try {
+            if (!dom || 1 !== dom.nodeType) return '';
+            if ('OPTION' === dom.tagName) return '';
+            if ('BODY' === dom.tagName) return 'body';
+            if ('HTML' === dom.tagName) return 'html';
+            const children = Array.from(dom.parentNode.childNodes).filter(($el)=>1 === $el.nodeType);
+            const sameTagChildren = children.filter(($el)=>$el.tagName === dom.tagName);
+            let extra = '';
+            if (1 === sameTagChildren.length) extra = '';
+            else {
+                const index = children.findIndex((item)=>item === dom) + 1;
+                extra = `:nth-child(${index})`;
+            }
+            const me = dom.tagName.toLowerCase() + extra;
+            const parentSelector = getFullSelector(dom.parentNode);
+            return parentSelector ? parentSelector + ' > ' + me : me;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    if ('xpath' === type) return {
+        type: 'xpath',
+        value: getFullXpath(dom)
+    };
+    if ('querySelect' === type) return {
+        type: 'querySelect',
+        value: getFullSelector(dom)
+    };
+    const value = getFullXpath(dom);
+    if (value) return {
+        type: 'xpath',
+        value
+    };
+    return {
+        type: 'querySelect',
+        value: getFullSelector(dom)
+    };
+};
+const getPositionLocator = (ele)=>{
+    const getPositionXPath = (ele)=>{
+        try {
+            if (!ele || 1 !== ele.nodeType) return '';
+            if ('OPTION' === ele.tagName) return '';
+            const root = ele.getRootNode();
+            if (isShadowRoot(root)) return '';
+            const useFieldId = !!document.querySelector('*[fieldid]');
+            let path = '';
+            let dom = ele;
+            while(dom && 1 === dom.nodeType){
+                let currentPath = '';
+                currentPath = 'BODY' === dom.tagName ? '/body' : 'HTML' === dom.tagName ? '/html' : getRelativeXpath(dom, useFieldId);
+                path = currentPath + path;
+                const locator = '/' + path;
+                if (useFieldId && locator.includes('textCol|')) return '';
+                if (verifyXPath(locator, ele)) return locator;
+                dom = dom.parentNode;
+            }
+            return path;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    const getPositionSelector = (ele)=>{
+        try {
+            let path = '';
+            let dom = ele;
+            if (dom && 'OPTION' === dom.tagName) return '';
+            const useFieldId = !!document.querySelector('*[fieldid]');
+            while(dom && 1 === dom.nodeType){
+                let currentPath;
+                currentPath = 'BODY' === dom.tagName ? 'body' : 'HTML' === dom.tagName ? 'html' : getRelativeSelector(dom, useFieldId);
+                path = path ? currentPath + ' > ' + path : currentPath;
+                if (useFieldId && path.includes('textCol|')) return '';
+                if (verifySelector(path, ele)) break;
+                dom = dom.parentNode;
+            }
+            return path;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    const value = getPositionXPath(ele);
+    if (value) return {
+        type: 'xpath',
+        value
+    };
+    return {
+        type: 'querySelect',
+        value: getPositionSelector(ele)
+    };
+};
+const getFirstText = (ele)=>{
+    var _texts_;
+    const texts = Array.from(ele.childNodes).filter((n)=>3 === n.nodeType).filter((node)=>node.textContent && node.textContent.trim() && !/[\{\}\"\'\\\/]/.test(node.textContent) && node.textContent.trim().length < 30);
+    return (null == (_texts_ = texts[0]) ? void 0 : _texts_.textContent) || null;
+};
+const getXpathWidthText = (dom)=>{
+    if (!dom || 1 !== dom.nodeType) return '';
+    const root = dom.getRootNode();
+    if (isShadowRoot(root)) return '';
+    let locator = '';
+    let text = getFirstText(dom);
+    if (text) locator = text.length < 30 ? `//${dom.nodeName.toLowerCase()}[text()=${attributeValue(text)}]` : `//${dom.nodeName.toLowerCase()}[contains(text(),${attributeValue(text.slice(0, 30))})]`;
+    return verifyXPath(locator, dom);
+};
+const getXpathWidthInnerText = (dom)=>{
+    try {
+        if (!dom || 1 !== dom.nodeType) return null;
+        const root = dom.getRootNode();
+        if (isShadowRoot(root)) return null;
+        const text = dom.textContent.replace(/\s+/g, ' ');
+        if (text && text.length < 30) {
+            const escapedText = text.replace(/"/g, '\\"').replace(/'/g, "\\'");
+            const tagName = dom.tagName.toLowerCase();
+            let parentNode = dom.parentNode;
+            let extra = `/${tagName}`;
+            while(parentNode){
+                let parentNodeName = parentNode.nodeName.toLowerCase();
+                if (parentNodeName !== tagName) break;
+                extra = `/${parentNodeName}${extra}`;
+                parentNode = parentNode.parentNode;
+            }
+            const locator = `/${extra}[contains(.,'${escapedText}')]`;
+            return verifyXPath(locator, dom);
+        }
+        return null;
+    } catch (error) {
+        console.error(error);
+        return null;
+    }
+};
+const getLocatorUntilAllFieldid = (ele)=>{
+    const getXpathUntilAllFieldid = (ele)=>{
+        try {
+            if (!ele || 1 !== ele.nodeType) return '';
+            const root = ele.getRootNode();
+            if (isShadowRoot(root)) return '';
+            const useFieldId = !!document.querySelector('*[fieldid]');
+            let path = '';
+            let dom = ele;
+            while(dom && 1 === dom.nodeType){
+                if (useFieldId && path.includes('textCol|') && !dom.getAttribute('childrenfield')) {
+                    dom = dom.parentNode;
+                    continue;
+                }
+                const currentPath = getRelativeXpath(dom, useFieldId);
+                if (currentPath) if (/\[@/g.test(path)) {
+                    if (/\[@/g.test(path) && /\[@/g.test(currentPath) && !path.startsWith('//')) path = '/' + currentPath + '/' + path;
+                    else if (/\[@/g.test(path) && /\[@/g.test(currentPath)) path = '/' + currentPath + path;
+                } else path = currentPath + path;
+                const count = (path.match(/\[@/g) || []).length;
+                if (count >= 2) break;
+                dom = dom.parentNode;
+            }
+            if (path && !path.startsWith('//')) path = '/' + path;
+            return path;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    const getSelectorUntilAllFieldid = (ele)=>{
+        try {
+            if (!ele || 1 !== ele.nodeType) return '';
+            const root = ele.getRootNode();
+            if (isShadowRoot(root)) return '';
+            const useFieldId = !!document.querySelector('*[fieldid]');
+            let path = '';
+            let dom = ele;
+            while(dom && 1 === dom.nodeType){
+                if (useFieldId && path.includes('textCol|') && !dom.getAttribute('childrenfield')) {
+                    dom = dom.parentNode;
+                    continue;
+                }
+                const currentPath = getRelativeSelector(dom, useFieldId);
+                if (currentPath) if (/\[fieldid|\[id/g.test(path)) {
+                    if (/\[fieldid|\[id/g.test(path) && /\[fieldid|\[id/g.test(currentPath)) path = currentPath + ' ' + path;
+                } else path = path ? currentPath + ' > ' + path : currentPath;
+                const count = (path.match(/\[fieldid|\[id/g) || []).length;
+                if (count >= 2) break;
+                dom = dom.parentNode;
+            }
+            return path;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    const value = getXpathUntilAllFieldid(ele);
+    if (value) return {
+        type: 'xpath',
+        value
+    };
+    return {
+        type: 'querySelect',
+        value: getSelectorUntilAllFieldid(ele)
+    };
+};
+const getContainerLocatorUntilAllFieldid = (ele)=>{
+    const getContainerXpathUntilAllFieldid = (ele)=>{
+        try {
+            if (!ele || 1 !== ele.nodeType) return '';
+            const root = ele.getRootNode();
+            if (isShadowRoot(root)) return '';
+            const useFieldId = !!document.querySelector('*[fieldid]');
+            let path = '';
+            let dom = ele;
+            while(dom && 1 === dom.nodeType){
+                const currentPath = getRelativeXpath(dom, useFieldId);
+                if ('IFRAME' === dom.tagName || 'FRAME' === dom.tagName || dom.shadowRoot || /\[@/g.test(currentPath)) path = '/' + currentPath + path;
+                const count = (path.match(/\[@/g) || []).length;
+                if (count >= 1) break;
+                dom = dom.parentNode;
+            }
+            if (!path.startsWith('//')) path = '/' + path;
+            return path;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    const getContainerSelectorUntilAllFieldid = (ele)=>{
+        try {
+            if (!ele || 1 !== ele.nodeType) return '';
+            const root = ele.getRootNode();
+            if (isShadowRoot(root)) return '';
+            const useFieldId = !!document.querySelector('*[fieldid]');
+            let path = '';
+            let dom = ele;
+            while(dom && 1 === dom.nodeType){
+                const currentPath = getRelativeSelector(dom, useFieldId);
+                if ('IFRAME' === dom.tagName || 'FRAME' === dom.tagName || dom.shadowRoot || /\[fieldid|\[id/g.test(currentPath)) path = path ? currentPath + " " + path : currentPath;
+                const count = (path.match(/\[fieldid|\[id/g) || []).length;
+                if (count >= 1) break;
+                dom = dom.parentNode;
+            }
+            return path;
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    };
+    const value = getContainerXpathUntilAllFieldid(ele);
+    if (value) return {
+        type: 'xpath',
+        value
+    };
+    return {
+        type: 'querySelect',
+        value: getContainerSelectorUntilAllFieldid(ele)
+    };
+};
+const notExit = (locators, type, value)=>{
+    if (!value) return false;
+    return !locators.find((item)=>item.type === type && item.value === value);
+};
+const getLocators = (dom)=>{
+    const locators = getBaseSelectors(dom);
+    const locatorByGetLocatorUntilFieldid = getLocatorUntilFieldid(dom);
+    if (notExit(locators, locatorByGetLocatorUntilFieldid.type, locatorByGetLocatorUntilFieldid.value)) locators.push(locatorByGetLocatorUntilFieldid);
+    const locatorByGetLocatorUntilAllFieldid = getLocatorUntilAllFieldid(dom);
+    if (notExit(locators, locatorByGetLocatorUntilAllFieldid.type, locatorByGetLocatorUntilAllFieldid.value)) locators.push(locatorByGetLocatorUntilAllFieldid);
+    const locatorByGetPositionLocator = getPositionLocator(dom);
+    if (notExit(locators, locatorByGetPositionLocator.type, locatorByGetPositionLocator.value)) locators.push(locatorByGetPositionLocator);
+    const textXPathValue = getXpathWidthText(dom);
+    if (notExit(locators, 'xpath', textXPathValue)) locators.push({
+        type: 'xpath',
+        value: textXPathValue
+    });
+    const innerTextXpathValue = getXpathWidthInnerText(dom);
+    if (notExit(locators, 'xpath', innerTextXpathValue)) locators.push({
+        type: 'xpath',
+        value: innerTextXpathValue
+    });
+    const sortedLocators = sortLocators(locators);
+    const list = getLocatorsWidthIndex(sortedLocators, dom);
+    return list;
+};
+const sortLocators = (locators)=>locators.slice().sort((a, b)=>{
+        const valueA = a.value;
+        const valueB = b.value;
+        const hasFieldIdA = valueA.includes('@fieldid');
+        const hasFieldIdB = valueB.includes('@fieldid');
+        const hasIdA = valueA.includes('@id') && !hasFieldIdA;
+        const hasIdB = valueB.includes('@id') && !hasFieldIdB;
+        if (hasFieldIdA !== hasFieldIdB) return hasFieldIdA ? -1 : 1;
+        if (hasIdA !== hasIdB) return hasIdA ? -1 : 1;
+        if (a.type !== b.type) return 'xpath' === a.type ? -1 : 1;
+        if (hasFieldIdA) {
+            const countA = (valueA.match(/\[@fieldid/g) || []).length;
+            const countB = (valueB.match(/\[@fieldid/g) || []).length;
+            return countA - countB;
+        }
+        if (!hasIdA) return valueA.length - valueB.length;
+        {
+            const countA = (valueA.match(/\[@id/g) || []).length;
+            const countB = (valueB.match(/\[@id/g) || []).length;
+            return countA - countB;
+        }
+    });
+const getContainerLocators = (dom)=>{
+    if (!dom || !isHostElement(dom) && 'IFRAME' !== dom.nodeName && 'FRAME' !== dom.nodeName) return [];
+    const locators = getBaseSelectors(dom);
+    const locatorByGetContainerLocatorUntilAllFieldid = getContainerLocatorUntilAllFieldid(dom);
+    if (notExit(locators, locatorByGetContainerLocatorUntilAllFieldid.type, locatorByGetContainerLocatorUntilAllFieldid.value)) locators.push(locatorByGetContainerLocatorUntilAllFieldid);
+    const locatorByGetPositionLocator = getPositionLocator(dom);
+    if (notExit(locators, locatorByGetPositionLocator.type, locatorByGetPositionLocator.value)) locators.push(locatorByGetPositionLocator);
+    const sortedLocators = sortLocators(locators);
+    const containerAllPaths = getLocatorsWidthIndex(sortedLocators, dom);
+    return containerAllPaths;
+};
+const getContainerLocatorData = (dom)=>{
+    var _containerAllPaths_, _containerAllPaths_1, _containerAllPaths_2;
+    const containerAllPaths = getContainerLocators(dom);
+    const containerType = dom.shadowRoot ? 'shadowRoot' : 'iframe';
+    return {
+        containerAllPaths,
+        containerType,
+        containerPathType: (null == (_containerAllPaths_ = containerAllPaths[0]) ? void 0 : _containerAllPaths_.type) || '',
+        containerPathValue: (null == (_containerAllPaths_1 = containerAllPaths[0]) ? void 0 : _containerAllPaths_1.value) || '',
+        containerPathIndex: (null == (_containerAllPaths_2 = containerAllPaths[0]) ? void 0 : _containerAllPaths_2.index) ?? 1
+    };
+};
+const getLocatorsWidthIndex = (locators, dom)=>{
+    const rootNode = dom.getRootNode();
+    const list = locators.map((item)=>{
+        const eles = getElementsByLocator(item, rootNode);
+        const eleIndex = eles.findIndex((el)=>el === dom);
+        if (-1 === eleIndex || eles.length > 5) return null;
+        return {
+            ...item,
+            index: eleIndex + 1
+        };
+    }).filter(Boolean);
+    if (0 === list.length) {
+        const locatorByGetFullLocator = getFullLocator(dom);
+        if (locatorByGetFullLocator.value) list.push({
+            type: locatorByGetFullLocator.type,
+            value: locatorByGetFullLocator.value,
+            index: 1
+        });
+    }
+    return list.map((item, index)=>({
+            ...item,
+            isSelected: 0 === index,
+            orderNum: index
+        }));
+};
+const getManyElementByLocators = (docOrHost = document, locators, selected = true)=>{
+    if (selected) {
+        const selectedLocator = locators.find((item)=>item.isSelected) || locators[0];
+        if (selectedLocator) return getElementsByLocator(selectedLocator, docOrHost);
+    } else {
+        const elements = locators.map((item)=>getElementsByLocator(item, docOrHost)).flat();
+        return Array.from(new Set(elements));
+    }
+    return [];
+};
+const getOneElementByLocators = (docOrHost, locators, selected = true)=>{
+    if (selected) {
+        const selectedLocator = locators.find((item)=>item.isSelected) || locators[0];
+        if (selectedLocator) {
+            const index = Math.max(0, (selectedLocator.index ?? 1) - 1);
+            return getElementsByLocator(selectedLocator, docOrHost)[index] || null;
+        }
+    } else {
+        let ele = null;
+        for(let i = 0; i < locators.length; i += 1){
+            const index = Math.max(0, (locators[i].index ?? 1) - 1);
+            ele = getElementsByLocator(locators[i], docOrHost)[index] || null;
+            if (ele) break;
+        }
+        return ele;
+    }
+    return null;
+};
+const getShadowRootContainerStack = (dom)=>{
+    const containers = [];
+    let ele = dom;
+    while(ele){
+        const rootNode = ele.getRootNode();
+        ele = rootNode.host;
+        if (ele) {
+            const container = getContainerLocatorData(ele);
+            containers.unshift(container);
+        } else break;
+    }
+    return containers;
+};
+exports.getContainerPath = __webpack_exports__.getContainerPath;
+exports.getElements = __webpack_exports__.getElements;
+exports.getFullLocator = __webpack_exports__.getFullLocator;
+exports.getLocatorUntilFieldid = __webpack_exports__.getLocatorUntilFieldid;
+exports.getLocators = __webpack_exports__.getLocators;
+exports.getShadowRootContainerStack = __webpack_exports__.getShadowRootContainerStack;
+exports.getUniqueElement = __webpack_exports__.getUniqueElement;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getContainerPath",
+    "getElements",
+    "getFullLocator",
+    "getLocatorUntilFieldid",
+    "getLocators",
+    "getShadowRootContainerStack",
+    "getUniqueElement"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});