ff-automationv2 2.2.28 → 2.2.29

package/dist/fireflinkData/fireflinkLocators/utils/xpathHelpers.js

@@ -0,0 +1,1647 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xpathUtils = exports.getPlatformFallbackXpath = exports.findMatchingParenthesis = exports.normalizeXPath = exports.getReferenceElementsXpath = exports.replaceActualAttributes = exports.getXpathString = exports.getTextXpathFunction = exports.getUniqueNodeAnchorXpaths = exports.getAxisNodeTest = exports.isExactUniqueXpath = exports.getFirstMatchedNode = exports.getTagOnlyXPath = exports.getOrAttributesXPath = exports.getContainsPropertyXPath = exports.getStartsWithPropertyXPath = exports.getNormalizedPropertyXPath = exports.getFilteredTextXPath = exports.intermediateXpathStep = exports.getAttributeCombinationXpath = exports.getCombinationXpath = exports.getRelativeXPath = exports.getAbsoluteXPath = exports.getPropertyXPath = exports.replaceTempAttributes = exports.isSvg = exports.getRelationship = exports.checkBlockedAttributes = exports.createShadowEvaluationContext = exports.getShadowRoot = exports.replaceWhiteSpaces = exports.findXpathWithIndex = exports.removeParenthesis = exports.escapeCharacters = exports.getCountOfXPath = exports.getFilteredText = exports.getTextContent = exports.buildPattern = exports.isNumberExist = exports.sanitizeAttributeValue = exports.modifiedElementAttributes = exports.evaluateXPathOnce = exports.clearXPathEvalCache = exports.timeLog = exports.cspEnabled = exports.reWhiteSpace = void 0;
+exports.evaluateXPath = evaluateXPath;
+exports.escapeAttrValue = escapeAttrValue;
+exports.isUniqueInDOM = isUniqueInDOM;
+const logData_1 = require("../../../utils/logger/logData");
+exports.reWhiteSpace = /^[\S]+( [\S]+)*$/i;
+exports.cspEnabled = false;
+// const xpathCache: { [x: string]: number } = {};
+const timeLog = (label, start) => {
+    const duration = performance.now() - start;
+    logData_1.logger.info(`⏱️ ${label}: ${duration.toFixed(2)}ms time`);
+};
+exports.timeLog = timeLog;
+// cache per context node → avoids cross-context pollution
+let xpathEvalCache = new WeakMap();
+const getXPathContext = (docmt) => {
+    const owner = docmt.nodeType === 9
+        ? docmt
+        : docmt.ownerDocument || document;
+    // valid XPath context nodes: Element(1), Document(9), DocumentFragment/ShadowRoot(11)
+    const contextNode = docmt.nodeType === 1 || docmt.nodeType === 9 || docmt.nodeType === 11
+        ? docmt
+        : owner;
+    return contextNode;
+};
+const getMutationCacheContexts = (node) => {
+    const contexts = [];
+    const addContext = (candidate) => {
+        if (!candidate || contexts.includes(candidate))
+            return;
+        contexts.push(candidate);
+    };
+    addContext(node);
+    const rootNode = node.getRootNode?.();
+    if (rootNode instanceof Document || rootNode instanceof ShadowRoot) {
+        addContext(rootNode);
+    }
+    const ownerDocument = node.nodeType === 9
+        ? node
+        : node.ownerDocument;
+    addContext(ownerDocument);
+    return contexts;
+};
+const clearXPathEvalCache = (node) => {
+    if (!node) {
+        xpathEvalCache = new WeakMap();
+        return;
+    }
+    getMutationCacheContexts(node).forEach((contextNode) => {
+        xpathEvalCache.delete(contextNode);
+    });
+};
+exports.clearXPathEvalCache = clearXPathEvalCache;
+function svgXPathFallback(xpath, root) {
+    const tag = xpath.match(/local-name\(\)\s*=\s*['"]([^'"]+)['"]/)?.[1];
+    if (!tag)
+        return [];
+    let elements = Array.from(root.querySelectorAll(tag));
+    // contains(@attr,'value')
+    const containsMatch = xpath.match(/contains\(@([^,]+),['"]([^'"]+)['"]\)/);
+    if (containsMatch) {
+        const [, attr, value] = containsMatch;
+        elements = elements.filter(el => el.getAttribute(attr)?.includes(value));
+    }
+    // starts-with(@attr,'value')
+    const startsWithMatch = xpath.match(/starts-with\(@([^,]+),['"]([^'"]+)['"]\)/);
+    if (startsWithMatch) {
+        const [, attr, value] = startsWithMatch;
+        elements = elements.filter(el => el.getAttribute(attr)?.startsWith(value));
+    }
+    // @attr='value'
+    const attrMatch = xpath.match(/@([^=]+)=['"]([^'"]+)['"]/);
+    if (attrMatch) {
+        const [, attr, value] = attrMatch;
+        elements = elements.filter(el => el.getAttribute(attr) === value);
+    }
+    return elements;
+}
+function evaluateXPath(xpath, contextNode, mode = "iterator") {
+    const owner = contextNode.nodeType === 9
+        ? contextNode
+        : contextNode.ownerDocument;
+    try {
+        switch (mode) {
+            case "first":
+                return owner.evaluate(xpath, contextNode, null, owner.defaultView.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+            case "snapshot":
+                return owner.evaluate(xpath, contextNode, null, owner.defaultView.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+            default:
+                return owner.evaluate(xpath, contextNode, null, owner.defaultView.XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
+        }
+    }
+    catch (e) {
+        logData_1.logger.error(` Error in evaluating xpath: ${e.message}`);
+        const root = contextNode.nodeType === 9
+            ? contextNode
+            : contextNode.ownerDocument;
+        const nodes = svgXPathFallback(xpath, root);
+        if (mode === "first") {
+            return {
+                singleNodeValue: nodes[0] ?? null
+            };
+        }
+        if (mode === "snapshot") {
+            return {
+                snapshotLength: nodes.length,
+                snapshotItem: (i) => nodes[i] ?? null
+            };
+        }
+        let index = 0;
+        return {
+            iterateNext: () => nodes[index++] ?? null
+        };
+    }
+}
+const evaluateXPathOnce = (xpath, docmt) => {
+    const contextNode = getXPathContext(docmt);
+    // get or create cache for this context node
+    let nodeCache = xpathEvalCache.get(contextNode);
+    if (!nodeCache) {
+        nodeCache = new Map();
+        xpathEvalCache.set(contextNode, nodeCache);
+    }
+    // cache hit
+    const cached = nodeCache.get(xpath);
+    if (cached)
+        return cached;
+    // evaluate once, stop after 2 nodes
+    // const result = owner.evaluate(
+    //   xpath,
+    //   contextNode,
+    //   null,
+    //   owner.defaultView!.XPathResult.ORDERED_NODE_ITERATOR_TYPE,
+    //   null
+    // );
+    const result = evaluateXPath(xpath, contextNode);
+    const first = result.iterateNext();
+    const second = result.iterateNext();
+    const evalResult = { first, second };
+    nodeCache.set(xpath, evalResult);
+    return evalResult;
+};
+exports.evaluateXPathOnce = evaluateXPathOnce;
+const relativeXPathCache = new Map();
+exports.modifiedElementAttributes = [];
+const INTERNAL_CLASS_TOKENS = new Set([
+    "marked-element-temp",
+    "removePointers"
+]);
+const normalizeClassTokens = (classValue) => (classValue || "")
+    .split(/\s+/)
+    .map((token) => token.trim())
+    .filter((token) => token && !INTERNAL_CLASS_TOKENS.has(token))
+    .sort();
+const sanitizeAttributeValue = (attributeName, attributeValue) => {
+    if (!attributeValue) {
+        return "";
+    }
+    if (attributeName === "class" || attributeName === "className") {
+        return normalizeClassTokens(attributeValue).join(" ");
+    }
+    return attributeValue.replace("removePointers", "").trim();
+};
+exports.sanitizeAttributeValue = sanitizeAttributeValue;
+const isNumberExist = (str) => {
+    const hasNumber = /\d/;
+    return hasNumber.test(str);
+};
+exports.isNumberExist = isNumberExist;
+const buildPattern = (pattern, isSvg, tagName) => {
+    return isSvg
+        ? `//*[local-name()='${tagName}' and ${pattern}]`
+        : `//${tagName}[${pattern}]`;
+};
+exports.buildPattern = buildPattern;
+const getTextContent = (targetElement) => {
+    const textContent = targetElement?.textContent;
+    if (exports.cspEnabled) {
+        if (textContent) {
+            const tooltip = document.querySelector(".flntooltip");
+            if (tooltip) {
+                const lastIndex = textContent.lastIndexOf(tooltip.innerText);
+                if (lastIndex &&
+                    textContent.length === lastIndex + tooltip.innerText.length) {
+                    return textContent.substring(0, lastIndex);
+                }
+            }
+            else {
+                return textContent;
+            }
+        }
+    }
+    else {
+        return textContent;
+    }
+    return "";
+};
+exports.getTextContent = getTextContent;
+const getFilteredText = (element) => {
+    return element?.childNodes[0]?.nodeValue || "";
+};
+exports.getFilteredText = getFilteredText;
+const getCountOfXPath = (xpath, element, docmt, multiElementReferenceMode = false) => {
+    try {
+        const { first, second } = (0, exports.evaluateXPathOnce)(xpath, docmt);
+        if (!first)
+            return 0;
+        //  exactly one match
+        if (!second) {
+            return first === element ? 1 : 0;
+        }
+        // multiple matches
+        if (multiElementReferenceMode && Array.isArray(element)) {
+            let matchCount = 0;
+            if (element.includes(first))
+                matchCount++;
+            if (element.includes(second))
+                matchCount++;
+            if (matchCount === 2)
+                return 2;
+            // const result = owner.evaluate(
+            //   xpath,
+            //   docmt,
+            //   null,
+            //   owner.defaultView!.XPathResult.ORDERED_NODE_ITERATOR_TYPE,
+            //   null
+            // );
+            const result = evaluateXPath(xpath, docmt);
+            let node;
+            while ((node = result.iterateNext())) {
+                if (element.includes(node)) {
+                    matchCount++;
+                    if (matchCount === 2)
+                        return 2;
+                }
+            }
+            return 0;
+        }
+        return 2;
+    }
+    catch (error) {
+        console.error(`Error evaluating XPath: ${xpath}`, error);
+        return 0;
+    }
+};
+exports.getCountOfXPath = getCountOfXPath;
+const escapeCharacters = (text) => {
+    if (text) {
+        if (!(text.indexOf('"') === -1)) {
+            return `'${text}'`;
+        }
+        if (!(text.indexOf("'") === -1)) {
+            return `"${text}"`;
+        }
+    }
+    return `'${text}'`;
+};
+exports.escapeCharacters = escapeCharacters;
+const removeParenthesis = (xpath) => {
+    const charArr = xpath.split("");
+    let count = charArr.length;
+    const indexArray = [];
+    while (charArr[count - 2] !== "[") {
+        indexArray.push(charArr[count - 2]);
+        count--;
+    }
+    indexArray.reverse();
+    let finalStr = "";
+    for (let i = 0; i < indexArray.length; i++) {
+        finalStr += indexArray[i];
+    }
+    const endBracketLength = finalStr.length + 2;
+    let firstpart = xpath.slice(0, xpath.length - endBracketLength);
+    if (firstpart.startsWith("(") && firstpart.endsWith(")")) {
+        firstpart = firstpart.slice(1, -1);
+    }
+    else {
+        firstpart = xpath;
+    }
+    return firstpart;
+};
+exports.removeParenthesis = removeParenthesis;
+const findXpathWithIndex = (val, node, docmt, count) => {
+    try {
+        let index = 0;
+        if (count) {
+            if ((0, exports.getCountOfXPath)(`${val}[${count}]`, node, docmt) === 1) {
+                return `${val}[${count}]`;
+            }
+            if ((0, exports.getCountOfXPath)(`(${val})[${count}]`, node, docmt) === 1) {
+                return `(${val})[${count}]`;
+            }
+        }
+        // const nodes = owner.evaluate(val, docmt, null, owner.defaultView!.XPathResult.ANY_TYPE, null);
+        const nodes = evaluateXPath(val, docmt);
+        let nodex = null;
+        while ((nodex = nodes.iterateNext())) {
+            index++;
+            if (nodex.isSameNode(node)) {
+                if ((0, exports.getCountOfXPath)(`${val}[${index}]`, node, docmt) === 1) {
+                    return `${val}[${index}]`;
+                }
+                if ((0, exports.getCountOfXPath)(`(${val})[${index}]`, node, docmt) === 1) {
+                    return `(${val})[${index}]`;
+                }
+                return;
+            }
+        }
+    }
+    catch (error) {
+        logData_1.logger.error(error);
+    }
+};
+exports.findXpathWithIndex = findXpathWithIndex;
+const deleteLineGap = (a) => {
+    a && (a = a.split("\n")[0].length > 0 ? a.split("\n")[0] : a.split("\n")[1]);
+    return a;
+};
+const deleteGarbageFromInnerText = (a) => {
+    a = deleteLineGap(a);
+    a = a
+        .split(/[^\p{ASCII}\u0080-\u00FF]/u)
+        .reduce((b, c) => {
+        return b.length > c.length ? b : c;
+    }, "")
+        .trim();
+    return (a.split("/")[0].trim());
+};
+const replaceWhiteSpaces = (str) => {
+    if (str) {
+        return str.replace(/\s\s+/g, " ").trim();
+    }
+    return str;
+};
+exports.replaceWhiteSpaces = replaceWhiteSpaces;
+const getShadowRoot = (el) => {
+    if (!el || !el?.getRootNode)
+        return null;
+    const root = el.getRootNode();
+    return root && root?.host ? root : null;
+};
+exports.getShadowRoot = getShadowRoot;
+const isShadowRootNode = (node) => {
+    return node?.nodeType === 11 && "host" in node;
+};
+const getElementPathFromRoot = (root, element) => {
+    const path = [];
+    let current = element;
+    while (current && current.parentElement) {
+        const parent = current.parentElement;
+        path.unshift(Array.from(parent.children).indexOf(current));
+        current = parent;
+    }
+    if (!current || current.parentNode !== root) {
+        return null;
+    }
+    path.unshift(Array.from(root.children).indexOf(current));
+    return path;
+};
+const getElementAtPath = (container, path) => {
+    let current = container;
+    for (const index of path) {
+        const next = current.children.item(index);
+        if (!next) {
+            return null;
+        }
+        current = next;
+    }
+    return current;
+};
+const createShadowEvaluationContext = (root, element) => {
+    const tempDoc = root.ownerDocument.implementation.createHTMLDocument("shadow-xpath");
+    const wrapper = tempDoc.createElement("div");
+    wrapper.innerHTML = root.innerHTML;
+    tempDoc.body.appendChild(wrapper);
+    const cloneForElement = (candidate) => {
+        if (!candidate ||
+            !(candidate instanceof root.ownerDocument.defaultView.Element)) {
+            return null;
+        }
+        const path = getElementPathFromRoot(root, candidate);
+        return path ? getElementAtPath(wrapper, path) : null;
+    };
+    const cloneElements = Array.isArray(element)
+        ? element.map((candidate) => cloneForElement(candidate)).filter(Boolean)
+        : [];
+    const cloneElement = Array.isArray(element)
+        ? null
+        : cloneForElement(element ?? null);
+    return {
+        contextNode: wrapper,
+        cloneElement,
+        cloneElements
+    };
+};
+exports.createShadowEvaluationContext = createShadowEvaluationContext;
+const checkBlockedAttributes = (attribute, targetElement, isTarget) => {
+    const sanitizedValue = (0, exports.sanitizeAttributeValue)(attribute.name, attribute.value);
+    if (!sanitizedValue || typeof attribute?.value === "boolean") {
+        return false;
+    }
+    const blockedValues = [
+        "true",
+        "false",
+        "on",
+        "off",
+        "flntooltip",
+        "flutter-highlight-overlay"
+    ];
+    if (blockedValues.some((x) => x === sanitizedValue)) {
+        return false;
+    }
+    const blockedNames = [
+        "style",
+        "locator-data-tooltip",
+        "value",
+        "ff-inspect",
+        "ff-inspecter",
+        "ff-xpath"
+    ];
+    if (blockedNames.some((x) => x.toLowerCase() === attribute.name.toLowerCase())) {
+        return false;
+    }
+    const isModified = exports.modifiedElementAttributes?.find((x) => x.doc === targetElement.ownerDocument &&
+        x.element === targetElement &&
+        x.attributeName === attribute.name);
+    if (isModified) {
+        return false;
+    }
+    if (attribute?.name?.indexOf("on") === 0 && attribute?.name?.length > 3) {
+        return false;
+    }
+    if (typeof attribute.value === "function") {
+        return false;
+    }
+    if (isTarget && (0, exports.isNumberExist)(sanitizedValue)) {
+        return false;
+    }
+    return true;
+};
+exports.checkBlockedAttributes = checkBlockedAttributes;
+const getRelationship = (a, b) => {
+    const pos = a.compareDocumentPosition(b);
+    return pos === 2
+        ? "preceding"
+        : pos === 4
+            ? "following"
+            : pos === 8
+                ? "ancestor"
+                : pos === 16
+                    ? "descendant"
+                    : pos === 32
+                        ? "self"
+                        : "";
+};
+exports.getRelationship = getRelationship;
+const isSvg = (element) => {
+    return element instanceof element.ownerDocument.defaultView.SVGElement;
+};
+exports.isSvg = isSvg;
+const replaceTempAttributes = (str) => {
+    if (!str)
+        return str;
+    return str.replace(/\b[a-zA-Z_]*disabled\b/gi, "disabled");
+};
+exports.replaceTempAttributes = replaceTempAttributes;
+const getPropertyXPath = (element, docmt, prop, value, isIndex, isTarget, platform) => {
+    if (value) {
+        const { tagName } = element;
+        let count;
+        let combinePattern = "";
+        const mergePattern = [];
+        let pattern;
+        let elementTagName = element.tagName;
+        if (value && (!isTarget || !(0, exports.isNumberExist)(value))) {
+            if (!exports.reWhiteSpace.test(value)) {
+                if (platform == 'web') {
+                    elementTagName = element.tagName.toLowerCase();
+                }
+                pattern = (0, exports.buildPattern)(`normalize-space(${prop})=${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(value)).trim()}`, (0, exports.isSvg)(element), elementTagName);
+            }
+            else {
+                pattern = `//${elementTagName}[${prop}=${(0, exports.escapeCharacters)(value)}]`;
+            }
+            count = (0, exports.getCountOfXPath)(pattern, element, docmt);
+            if (count === 1 && !isIndex) {
+                return pattern;
+            }
+        }
+        if (value && isTarget) {
+            const splitText = value.split(" ");
+            if (splitText?.length) {
+                if (splitText.length === 1) {
+                    const contentRes = [...new Set(splitText[0].match(/([^0-9]+)/g))];
+                    if (contentRes?.length >= 1) {
+                        if (contentRes[0] &&
+                            (0, exports.replaceWhiteSpaces)(contentRes[0].trim())?.length > 1) {
+                            if (value.startsWith(contentRes[0])) {
+                                if (!exports.reWhiteSpace.test(contentRes[0])) {
+                                    combinePattern = `starts-with(${prop},${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(contentRes[0])).trim()})`;
+                                }
+                                else {
+                                    combinePattern = `starts-with(${prop},${(0, exports.escapeCharacters)(contentRes[0]).trim()})`;
+                                }
+                            }
+                        }
+                    }
+                    if (contentRes?.length > 1) {
+                        if (contentRes[contentRes.length - 1] &&
+                            (0, exports.replaceWhiteSpaces)(contentRes[contentRes.length - 1].trim())
+                                ?.length > 1) {
+                            if (value.endsWith(contentRes[contentRes.length - 1])) {
+                                if (!exports.reWhiteSpace.test(contentRes[contentRes.length - 1])) {
+                                    combinePattern = `ends-with(${prop},${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(contentRes[contentRes.length - 1])).trim()})`;
+                                }
+                                else {
+                                    combinePattern = `ends-with(${prop},${(0, exports.escapeCharacters)(contentRes[contentRes.length - 1]).trim()})`;
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        if ((0, exports.isSvg)(element)) {
+                            pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                        }
+                        else {
+                            pattern = `//${tagName}[${combinePattern}]`;
+                        }
+                        count = (0, exports.getCountOfXPath)(pattern, element, docmt);
+                        if (count === 1 && !isIndex) {
+                            return pattern;
+                        }
+                    }
+                }
+                else {
+                    const endIndex = splitText.length % 2 === 0
+                        ? splitText.length / 2
+                        : splitText.length % 2;
+                    const startIndexString = splitText.slice(0, endIndex).join(" ");
+                    let contentRes = [...new Set(startIndexString.match(/([^0-9]+)/g))];
+                    if (contentRes?.length) {
+                        if (contentRes[0] &&
+                            (0, exports.replaceWhiteSpaces)(contentRes[0].trim())?.length) {
+                            if (value.startsWith(contentRes[0])) {
+                                if (!exports.reWhiteSpace.test(contentRes[0])) {
+                                    combinePattern = `starts-with(${prop},${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(contentRes[0])).trim()})`;
+                                }
+                                else {
+                                    combinePattern = `starts-with(${prop},${(0, exports.escapeCharacters)(contentRes[0]).trim()})`;
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        if ((0, exports.isSvg)(element)) {
+                            pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                        }
+                        else {
+                            pattern = `//${tagName}[${combinePattern}]`;
+                        }
+                        count = (0, exports.getCountOfXPath)(pattern, element, docmt);
+                        if (count === 1 && !isIndex) {
+                            return pattern;
+                        }
+                    }
+                    const endIndexString = splitText
+                        .slice(endIndex, splitText.length - 1)
+                        .join(" ");
+                    contentRes = [...new Set(endIndexString.match(/([^0-9]+)/g))];
+                    if (contentRes?.length) {
+                        if (contentRes[0] &&
+                            (0, exports.replaceWhiteSpaces)(contentRes[0].trim())?.length > 3) {
+                            if (value.endsWith(contentRes[0])) {
+                                if (!exports.reWhiteSpace.test(contentRes[0])) {
+                                    combinePattern = `ends-with(${prop},${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(contentRes[0])).trim()})`;
+                                }
+                                else {
+                                    combinePattern = `ends-with(${prop},${(0, exports.escapeCharacters)(contentRes[0]).trim()})`;
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        if ((0, exports.isSvg)(element)) {
+                            pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                        }
+                        else {
+                            pattern = `//${tagName}[${combinePattern}]`;
+                        }
+                        count = (0, exports.getCountOfXPath)(pattern, element, docmt);
+                        if (count === 1 && !isIndex) {
+                            return pattern;
+                        }
+                    }
+                }
+            }
+        }
+        if (value && isTarget && (0, exports.isNumberExist)(value)) {
+            const contentRes = [...new Set(value.match(/([^0-9]+)/g))];
+            if (contentRes?.length) {
+                for (let i = 0; i < contentRes?.length; i++) {
+                    if (contentRes[i] &&
+                        (0, exports.replaceWhiteSpaces)(contentRes[i].trim())?.length > 1) {
+                        if (!exports.reWhiteSpace.test(contentRes[i])) {
+                            mergePattern.push(`contains(${prop},${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(contentRes[i])).trim()})`);
+                        }
+                        else {
+                            mergePattern.push(`contains(${prop},${(0, exports.escapeCharacters)(contentRes[i].trim()).trim()})`);
+                        }
+                    }
+                }
+            }
+            if (mergePattern?.length) {
+                if ((0, exports.isSvg)(element)) {
+                    pattern = `//*[local-name()='${tagName}' and ${mergePattern.join(" and ")}]`;
+                }
+                else {
+                    pattern = `//${tagName}[${mergePattern.join(" and ")}]`;
+                }
+                count = (0, exports.getCountOfXPath)(pattern, element, docmt);
+                if (count === 1 && !isIndex) {
+                    return pattern;
+                }
+            }
+        }
+        if ((0, exports.isSvg)(element)) {
+            pattern = `//*[local-name()='${tagName}' and text()]`;
+        }
+        else {
+            pattern = `//${tagName}[text()]`;
+        }
+        count = (0, exports.getCountOfXPath)(pattern, element, docmt);
+        if (count === 1 && !isIndex) {
+            return pattern;
+        }
+    }
+};
+exports.getPropertyXPath = getPropertyXPath;
+const getAbsoluteXPath = (domNode, docmt) => {
+    try {
+        if (!domNode) {
+            return "";
+        }
+        let xpathe = (0, exports.isSvg)(domNode)
+            ? `/*[local-name()='${domNode.tagName}']`
+            : `/${domNode.tagName}`;
+        // // If this node has siblings of the same tagName, get the index of this node
+        if (domNode.parentElement) {
+            // Get the siblings
+            const childNodes = Array.prototype.slice
+                .call(domNode.parentElement.children, 0)
+                .filter((childNode) => childNode.tagName === domNode.tagName);
+            //   // If there's more than one sibling, append the index
+            if (childNodes.length > 1) {
+                const index = childNodes.indexOf(domNode);
+                xpathe += `[${index + 1}]`;
+            }
+        }
+        else if (domNode instanceof HTMLElement) {
+            if (domNode.offsetParent) {
+                const childNodes = Array.prototype.slice
+                    .call(domNode.offsetParent.children, 0)
+                    .filter((childNode) => childNode.tagName === domNode.tagName);
+                //   // If there's more than one sibling, append the index
+                if (childNodes.length > 1) {
+                    const index = childNodes.indexOf(domNode);
+                    xpathe += `[${index + 1}]`;
+                }
+            }
+        }
+        // // Make a recursive call to this nodes parents and prepend it to this xpath
+        return (0, exports.getAbsoluteXPath)(domNode?.parentElement, docmt) + xpathe;
+    }
+    catch (error) {
+        // If there's an unexpected exception, abort and don't get an XPath
+        logData_1.logger.error("xpath", error);
+        return "";
+    }
+};
+exports.getAbsoluteXPath = getAbsoluteXPath;
+const getRelativeXPath = (domNode, docmt, isIndex, isTarget = false, attributesArray) => {
+    try {
+        // Generate a cache key based on the node's identifier, index, and target flag
+        // Check if the result for this node is already cached
+        if (relativeXPathCache.has(domNode)) {
+            return relativeXPathCache.get(domNode);
+        }
+        // Initialize an array to hold parts of the XPath
+        const xpathParts = [];
+        let currentNode = domNode;
+        // Traverse up the DOM tree iteratively instead of using recursion
+        while (currentNode) {
+            let xpathe = "";
+            let hasUniqueAttr = false;
+            const attributes = domNode === currentNode
+                ? (attributesArray ?? currentNode.attributes)
+                : currentNode.attributes;
+            // Loop through attributes to check for unique identifiers
+            for (const attrName of Array.from(attributes)) {
+                if ((0, exports.checkBlockedAttributes)(attrName, currentNode, isTarget)) {
+                    const attrValue = (0, exports.sanitizeAttributeValue)(attrName.name, attrName.nodeValue);
+                    const elementName = attrName.name;
+                    // Construct an XPath based on attribute
+                    xpathe = (0, exports.getXpathString)(currentNode, elementName, attrValue);
+                    let othersWithAttr = 0;
+                    if (xpathe) {
+                        othersWithAttr = (0, exports.getCountOfXPath)(xpathe, currentNode, docmt);
+                        if (othersWithAttr === 1) {
+                            xpathParts.unshift((0, exports.replaceTempAttributes)(xpathe));
+                            hasUniqueAttr = true;
+                            break;
+                        }
+                    }
+                    if (othersWithAttr > 1 && isIndex) {
+                        xpathe = (0, exports.findXpathWithIndex)(xpathe, currentNode, docmt, othersWithAttr);
+                        if (xpathe) {
+                            xpathParts.unshift((0, exports.replaceTempAttributes)(xpathe));
+                            hasUniqueAttr = true;
+                            break;
+                        }
+                        // return replaceTempAttributes(xpathe);
+                    }
+                }
+            }
+            if (currentNode.textContent) {
+                if (!isTarget ||
+                    (isTarget && !(0, exports.isNumberExist)(currentNode.textContent))) {
+                    const reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+                    if (!reWhiteSpace.test(currentNode.textContent)) {
+                        xpathe = (0, exports.isSvg)(currentNode)
+                            ? `//*[local-name()='${currentNode.tagName}' and normalize-space(.)=${(0, exports.escapeCharacters)((0, exports.getFilteredText)(currentNode))}]`
+                            : `//${currentNode.tagName || "*"}[normalize-space(.)=${(0, exports.escapeCharacters)((0, exports.getFilteredText)(currentNode))}]`;
+                    }
+                    else {
+                        xpathe = (0, exports.isSvg)(currentNode)
+                            ? `//*[local-name()='${currentNode.tagName}' and .=${(0, exports.escapeCharacters)((0, exports.getFilteredText)(currentNode))}]`
+                            : `//${currentNode.tagName || "*"}[.=${(0, exports.escapeCharacters)((0, exports.getFilteredText)(currentNode))}]`;
+                    }
+                    const othersWithAttr = (0, exports.getCountOfXPath)(xpathe, currentNode, docmt);
+                    if (othersWithAttr === 1) {
+                        return xpathe;
+                    }
+                    if (othersWithAttr > 1 && isIndex) {
+                        xpathe = (0, exports.findXpathWithIndex)(xpathe, currentNode, docmt, othersWithAttr);
+                        return xpathe;
+                    }
+                }
+                else {
+                    const combinePattern = [];
+                    const contentRes = [
+                        ...new Set((0, exports.getFilteredText)(currentNode).match(/([^0-9]+)/g))
+                    ];
+                    const reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+                    if (contentRes?.length) {
+                        for (let i = 0; i < contentRes?.length; i++) {
+                            if (contentRes[i] &&
+                                (0, exports.replaceWhiteSpaces)(contentRes[i].trim())) {
+                                if (!reWhiteSpace.test(contentRes[i])) {
+                                    combinePattern.push(`contains(.,${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(contentRes[i])).trim()})`);
+                                }
+                                else {
+                                    combinePattern.push(`contains(.,${(0, exports.escapeCharacters)(contentRes[i].trim()).trim()})`);
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        xpathe = (0, exports.isSvg)(currentNode)
+                            ? `//*[local-name()='${currentNode.tagName}' and ${combinePattern.join(" and ")}]`
+                            : `//${currentNode.tagName || "*"}[${combinePattern.join(" and ")}]`;
+                        const othersWithAttr = (0, exports.getCountOfXPath)(xpathe, currentNode, docmt);
+                        if (othersWithAttr === 1) {
+                            return xpathe;
+                        }
+                        if (othersWithAttr > 1 && isIndex) {
+                            xpathe = (0, exports.findXpathWithIndex)(xpathe, currentNode, docmt, othersWithAttr);
+                            return xpathe;
+                        }
+                    }
+                }
+            }
+            // If no unique attribute was found, construct XPath by tag name
+            if (!hasUniqueAttr) {
+                let tagBasedXPath = (0, exports.isSvg)(currentNode)
+                    ? `/*[local-name()='${currentNode.tagName}']`
+                    : `/${currentNode.tagName}`;
+                // Handle sibling nodes
+                if (currentNode.parentElement) {
+                    const siblings = Array.from(currentNode.parentElement.children).filter((childNode) => childNode.tagName === currentNode.tagName);
+                    // Append index to distinguish between siblings
+                    if (siblings.length > 1) {
+                        const index = siblings.indexOf(currentNode);
+                        tagBasedXPath += `[${index + 1}]`;
+                    }
+                }
+                // Add the constructed tag-based XPath to the parts array
+                xpathParts.unshift(tagBasedXPath);
+            }
+            else {
+                break;
+            }
+            // Move up to the parent node for the next iteration
+            currentNode = currentNode.parentElement;
+        }
+        // Combine all parts into the final XPath
+        const finalXPath = `${xpathParts.join("")}`;
+        // Cache the final XPath for this node
+        relativeXPathCache.set(domNode, finalXPath);
+        return finalXPath;
+    }
+    catch (error) {
+        logData_1.logger.error(error);
+        return null;
+    }
+};
+exports.getRelativeXPath = getRelativeXPath;
+const getCombinationXpath = (attribute, domNode) => {
+    const combinePattern = [];
+    let pattern;
+    if (attribute &&
+        !(0, exports.isNumberExist)(attribute.value) &&
+        typeof attribute.nodeValue !== "function" // &&
+    // !modifiedElementAttributes?.find(
+    //   (x) => x.element === domNode && x.attributeName === attribute.name
+    // )
+    ) {
+        const contentRes = [...new Set(attribute.value.match(/([^0-9]+)/g))];
+        if (contentRes?.length) {
+            for (let i = 0; i < contentRes?.length; i++) {
+                if (contentRes[i] &&
+                    (0, exports.replaceWhiteSpaces)(contentRes[i].trim())?.length > 2) {
+                    if (!exports.reWhiteSpace.test(contentRes[i])) {
+                        combinePattern.push(`contains(@${attribute.name},${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(contentRes[i])).trim()})`);
+                    }
+                    else {
+                        combinePattern.push(`contains(@${attribute.name},${(0, exports.escapeCharacters)(contentRes[i].trim())})`);
+                    }
+                }
+            }
+        }
+        if (combinePattern?.length) {
+            pattern = (0, exports.isSvg)(domNode)
+                ? `//*[local-name()='${domNode.tagName}' and ${combinePattern.join(" and ")}]`
+                : `//${domNode.tagName}[${combinePattern.join(" and ")}]`;
+            return pattern;
+        }
+    }
+};
+exports.getCombinationXpath = getCombinationXpath;
+const getAttributeCombinationXpath = (domNode, docmt, uniqueAttributes, isTarget, platform) => {
+    try {
+        const candidateAttributes = uniqueAttributes.filter((attr) => (0, exports.checkBlockedAttributes)(attr, domNode, isTarget));
+        const buildAttributeConditions = (attribute) => {
+            const attrValue = (0, exports.sanitizeAttributeValue)(attribute.name, attribute.nodeValue);
+            if (!attrValue)
+                return [];
+            if (attribute.name === "class") {
+                const classTokens = attrValue
+                    .split(/\s+/)
+                    .map((token) => token.trim())
+                    .filter(Boolean);
+                if (!classTokens.length)
+                    return [];
+                const rankedTokens = classTokens
+                    .map((token) => {
+                    const xpath = (0, exports.buildPattern)(`contains(@class,${(0, exports.escapeCharacters)(token)})`, (0, exports.isSvg)(domNode), platform === "web" ? domNode.tagName.toLowerCase() : domNode.localName);
+                    return {
+                        token,
+                        count: getTagOnlyXpathCandidateCount(xpath, domNode, docmt)
+                    };
+                })
+                    .sort((left, right) => {
+                    if (left.count !== right.count) {
+                        return left.count - right.count;
+                    }
+                    return right.token.length - left.token.length;
+                });
+                return rankedTokens[0]?.token
+                    ? [`contains(@class,${(0, exports.escapeCharacters)(rankedTokens[0].token)})`]
+                    : [];
+            }
+            if (!exports.reWhiteSpace.test(attrValue)) {
+                return [`normalize-space(@${attribute.name})="${attrValue}"`];
+            }
+            return [`@${attribute.name}="${attrValue}"`];
+        };
+        const getTextConditions = () => {
+            const rawText = (0, exports.replaceWhiteSpaces)((0, exports.getTextContent)(domNode)?.trim() || "");
+            if (!rawText || rawText.length > 80 || /^\d+$/.test(rawText)) {
+                return [];
+            }
+            const conditions = new Set();
+            if (exports.reWhiteSpace.test(rawText) && rawText.length <= 40) {
+                conditions.add(`text()=${(0, exports.escapeCharacters)(rawText)}`);
+            }
+            if (rawText.includes(" ")) {
+                conditions.add(`normalize-space(text())=${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(rawText))}`);
+            }
+            conditions.add(`contains(text(),${(0, exports.escapeCharacters)(rawText)})`);
+            return Array.from(conditions);
+        };
+        const generateAttributeCombinations = (attributes, combinationSize) => {
+            const results = [];
+            const build = (startIndex, currentGroup) => {
+                if (currentGroup.length === combinationSize) {
+                    results.push([...currentGroup]);
+                    return;
+                }
+                for (let i = startIndex; i < attributes.length; i++) {
+                    currentGroup.push(attributes[i]);
+                    build(i + 1, currentGroup);
+                    currentGroup.pop();
+                }
+            };
+            build(0, []);
+            return results;
+        };
+        const buildXPath = (conditions) => (0, exports.isSvg)(domNode)
+            ? `//*[local-name()='${domNode.tagName}' and ${conditions.join(" and ")}]`
+            : `//${domNode.tagName}[${conditions.join(" and ")}]`;
+        const tryAttributeOnlyCombinations = () => {
+            if (candidateAttributes.length < 2) {
+                return undefined;
+            }
+            for (let combinationSize = 2; combinationSize <= candidateAttributes.length; combinationSize++) {
+                const attributeGroups = generateAttributeCombinations(candidateAttributes, combinationSize);
+                for (const attributeGroup of attributeGroups) {
+                    const xpathConditions = [];
+                    for (const attribute of attributeGroup) {
+                        const attributeConditions = buildAttributeConditions(attribute);
+                        if (!attributeConditions.length)
+                            continue;
+                        xpathConditions.push(...attributeConditions);
+                    }
+                    if (xpathConditions.length < 2)
+                        continue;
+                    const xpath = buildXPath(xpathConditions);
+                    let matchCount;
+                    try {
+                        matchCount = (0, exports.getCountOfXPath)(xpath, domNode, docmt);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (matchCount === 1) {
+                        return xpath;
+                    }
+                }
+            }
+            return undefined;
+        };
+        const attributeOnlyXpath = tryAttributeOnlyCombinations();
+        if (attributeOnlyXpath) {
+            return attributeOnlyXpath;
+        }
+        const textConditions = getTextConditions();
+        if (!textConditions.length || !candidateAttributes.length) {
+            return;
+        }
+        for (let combinationSize = 1; combinationSize <= candidateAttributes.length; combinationSize++) {
+            const attributeGroups = generateAttributeCombinations(candidateAttributes, combinationSize);
+            for (const attributeGroup of attributeGroups) {
+                const attributeConditions = [];
+                for (const attribute of attributeGroup) {
+                    attributeConditions.push(...buildAttributeConditions(attribute));
+                }
+                if (!attributeConditions.length) {
+                    continue;
+                }
+                for (const textCondition of textConditions) {
+                    const xpathConditions = [...attributeConditions, textCondition];
+                    const xpath = buildXPath(xpathConditions);
+                    try {
+                        if ((0, exports.getCountOfXPath)(xpath, domNode, docmt) === 1) {
+                            return xpath;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logData_1.logger.error(`XPath generation error: ${JSON.stringify(error, null, 2)}`);
+    }
+};
+exports.getAttributeCombinationXpath = getAttributeCombinationXpath;
+const intermediateXpathStep = (targetElemt, attr, isTarget) => {
+    const isSvgElement = (0, exports.isSvg)(targetElemt);
+    let expression = "";
+    if ((0, exports.checkBlockedAttributes)(attr, targetElemt, isTarget)) {
+        const attrValue = (0, exports.sanitizeAttributeValue)(attr.name, attr.value);
+        const elementName = attr.name;
+        if (!exports.reWhiteSpace.test(attrValue)) {
+            expression = isSvgElement
+                ? `*[local-name()='${targetElemt.tagName}' and normalize-space(@${elementName})=${(0, exports.escapeCharacters)(attrValue)}]`
+                : `${targetElemt.tagName || "*"}[normalize-space(@${elementName})=${(0, exports.escapeCharacters)(attrValue)}]`;
+        }
+        else {
+            expression = isSvgElement
+                ? `*[local-name()='${targetElemt.tagName}' and @${elementName}=${(0, exports.escapeCharacters)(attrValue)}]`
+                : `${targetElemt.tagName || "*"}[@${elementName}=${(0, exports.escapeCharacters)(attrValue)}]`;
+        }
+    }
+    return expression;
+};
+exports.intermediateXpathStep = intermediateXpathStep;
+const getFilteredTextXPath = (node) => {
+    if (!node.textContent)
+        return "";
+    const filteredText = (0, exports.getFilteredText)(node);
+    let xpathe;
+    if (!exports.reWhiteSpace.test(filteredText)) {
+        xpathe = (0, exports.isSvg)(node)
+            ? `//*[local-name()='${node.tagName}' and normalize-space(.)=${(0, exports.escapeCharacters)(filteredText)}]`
+            : `//${node.tagName || "*"}[normalize-space(.)=${(0, exports.escapeCharacters)(filteredText)}]`;
+    }
+    else {
+        xpathe = (0, exports.isSvg)(node)
+            ? `//*[local-name()='${node.tagName}' and .=${(0, exports.escapeCharacters)(filteredText)}]`
+            : `//${node.tagName || "*"}[.=${(0, exports.escapeCharacters)(filteredText)}]`;
+    }
+    return xpathe;
+};
+exports.getFilteredTextXPath = getFilteredTextXPath;
+const getNormalizedPropertyXPath = (element, prop, value, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const xpath = (0, exports.buildPattern)(`normalize-space(${prop})=${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(value)).trim()}`, (0, exports.isSvg)(element), elementTagName);
+    // logger.info("normalizedPropertyXPath", xpath)
+    return xpath;
+};
+exports.getNormalizedPropertyXPath = getNormalizedPropertyXPath;
+const getStartsWithPropertyXPath = (element, prop, value, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const xpath = (0, exports.buildPattern)(`starts-with(${prop},${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(value)).trim()})`, (0, exports.isSvg)(element), elementTagName);
+    // logger.info("getStartsWithPropertyXPath", xpath)
+    return xpath;
+};
+exports.getStartsWithPropertyXPath = getStartsWithPropertyXPath;
+const getContainsPropertyXPath = (element, prop, value, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const xpath = (0, exports.buildPattern)(`contains(${prop},${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(value)).trim()})`, (0, exports.isSvg)(element), elementTagName);
+    // logger.info("getContainsPropertyXPath", xpath)
+    return xpath;
+};
+exports.getContainsPropertyXPath = getContainsPropertyXPath;
+const getOrAttributesXPath = (element, attributes, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const buildAttributeCondition = (attribute) => {
+        const attrValue = (0, exports.sanitizeAttributeValue)(attribute.name, attribute.value);
+        if (!attrValue) {
+            return null;
+        }
+        if (attribute.name === "class") {
+            const classTokens = attrValue
+                .split(/\s+/)
+                .map((token) => token.trim())
+                .filter(Boolean);
+            const docmt = element.getRootNode?.() ??
+                element.ownerDocument;
+            const rankedToken = classTokens
+                .map((token) => {
+                const xpath = (0, exports.buildPattern)(`contains(@class,${(0, exports.escapeCharacters)(token)})`, (0, exports.isSvg)(element), elementTagName);
+                return {
+                    token,
+                    count: getTagOnlyXpathCandidateCount(xpath, element, docmt)
+                };
+            })
+                .sort((left, right) => {
+                if (left.count !== right.count) {
+                    return left.count - right.count;
+                }
+                return right.token.length - left.token.length;
+            })[0]?.token;
+            return rankedToken
+                ? `contains(@class,${(0, exports.escapeCharacters)(rankedToken)})`
+                : null;
+        }
+        if (!exports.reWhiteSpace.test(attrValue)) {
+            return `normalize-space(@${attribute.name})=${(0, exports.escapeCharacters)(attrValue)}`;
+        }
+        return `@${attribute.name}=${(0, exports.escapeCharacters)(attrValue)}`;
+    };
+    const buildTextCondition = () => {
+        const rawText = (0, exports.replaceWhiteSpaces)((0, exports.getTextContent)(element)?.trim() || "");
+        if (!rawText || rawText.length > 80 || /^\d+$/.test(rawText)) {
+            return null;
+        }
+        if (exports.reWhiteSpace.test(rawText) && rawText.length <= 40) {
+            return `text()=${(0, exports.escapeCharacters)(rawText)}`;
+        }
+        if (rawText.includes(" ")) {
+            return `normalize-space(text())=${(0, exports.escapeCharacters)(rawText)}`;
+        }
+        return `contains(text(),${(0, exports.escapeCharacters)(rawText)})`;
+    };
+    const attributeConditions = attributes
+        .map((attribute) => buildAttributeCondition(attribute))
+        .filter(Boolean);
+    if (attributeConditions.length >= 2) {
+        return (0, exports.buildPattern)(`${attributeConditions[0]} or ${attributeConditions[1]}`, (0, exports.isSvg)(element), elementTagName);
+    }
+    const textCondition = buildTextCondition();
+    if (attributeConditions.length === 1 && textCondition) {
+        return (0, exports.buildPattern)(`${attributeConditions[0]} or ${textCondition}`, (0, exports.isSvg)(element), elementTagName);
+    }
+    return "";
+};
+exports.getOrAttributesXPath = getOrAttributesXPath;
+const getTagOnlyXpathCandidateCount = (xpath, element, docmt) => {
+    try {
+        return (0, exports.getCountOfXPath)(xpath, element, docmt);
+    }
+    catch (_error) {
+        logData_1.logger.error(`error in getTagOnlyXpathCandidateCount ${_error.message}`);
+        return 0;
+    }
+};
+const getAncestorAnchorCandidates = (node, docmt, platform) => {
+    const anchors = [];
+    const seen = new Set();
+    const attributes = Array.from(node.attributes || []);
+    const priorityAttrs = [
+        "id",
+        "data-testid",
+        "data-test",
+        "data-qa",
+        "name",
+        "aria-label",
+        "role"
+    ];
+    const orderedAttributes = [
+        ...priorityAttrs
+            .map((attrName) => attributes.find((attr) => attr.name === attrName))
+            .filter(Boolean),
+        ...attributes.filter((attr) => !priorityAttrs.includes(attr.name))
+    ];
+    const pushAnchor = (xpath) => {
+        if (!xpath || seen.has(xpath))
+            return;
+        if ((0, exports.isExactUniqueXpath)(xpath, node, docmt)) {
+            seen.add(xpath);
+            anchors.push(xpath);
+        }
+    };
+    orderedAttributes.forEach((attr) => {
+        if (!(0, exports.checkBlockedAttributes)(attr, node, false))
+            return;
+        const xpath = attr.name === "id"
+            ? `//*[@id=${(0, exports.escapeCharacters)((0, exports.sanitizeAttributeValue)(attr.name, attr.value))}]`
+            : (0, exports.getXpathString)(node, attr.name, attr.value);
+        if (xpath) {
+            pushAnchor(xpath);
+        }
+    });
+    const text = node.textContent?.trim();
+    if (text && text.length < 40 && node.children.length === 0) {
+        const textXpath = (0, exports.getFilteredTextXPath)(node);
+        if (textXpath) {
+            pushAnchor(textXpath);
+        }
+    }
+    if (attributes.length > 1) {
+        const combinationXpath = (0, exports.getAttributeCombinationXpath)(node, docmt, attributes, false, platform);
+        if (combinationXpath) {
+            pushAnchor(combinationXpath);
+        }
+    }
+    return anchors;
+};
+const getStructuralPathFromAncestor = (ancestor, element, platform) => {
+    const steps = [];
+    let current = element;
+    while (current && current !== ancestor) {
+        steps.unshift((0, exports.getAxisNodeTest)(current, platform));
+        current = current.parentElement;
+    }
+    return current === ancestor ? steps.join("/") : "";
+};
+const getTagOnlyXPath = (element, platform, docmt) => {
+    const root = docmt ??
+        (element.getRootNode?.() ||
+            element.ownerDocument);
+    const tagName = (0, exports.getAxisNodeTest)(element, platform);
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const fallbackXpath = (0, exports.isSvg)(element)
+        ? `//*[local-name()='${elementTagName}']`
+        : `//${elementTagName}`;
+    for (let ancestor = element.parentElement; ancestor; ancestor = ancestor.parentElement) {
+        const ancestorAnchors = getAncestorAnchorCandidates(ancestor, root, platform);
+        for (const ancestorXpath of ancestorAnchors) {
+            // logger.info(`Trying ancestor XPath: ${ancestorXpath}`);
+            const descendantXpath = `${ancestorXpath}/descendant::${tagName}`;
+            // logger.info(`Trying descendant XPath: ${descendantXpath}`);
+            const count = getTagOnlyXpathCandidateCount(descendantXpath, element, root);
+            // logger.info(`Match count: ${count}`);
+            if (count === 1 &&
+                (0, exports.getFirstMatchedNode)(descendantXpath, root) === element) {
+                // logger.info(`Selected XPath: ${descendantXpath}`);
+                return descendantXpath;
+            }
+            const structuralPath = getStructuralPathFromAncestor(ancestor, element, platform);
+            if (structuralPath) {
+                const parentChainXpath = `${ancestorXpath}/${structuralPath}`;
+                // logger.info(`Trying descendant XPath: ${parentChainXpath}`);
+                const parentChainCount = getTagOnlyXpathCandidateCount(parentChainXpath, element, root);
+                // logger.info(`Match count: ${parentChainCount}`);
+                if (parentChainCount === 1 &&
+                    (0, exports.getFirstMatchedNode)(parentChainXpath, root) === element) {
+                    // logger.info(`Selected XPath: ${parentChainXpath}`);
+                    return parentChainXpath;
+                }
+            }
+        }
+    }
+    // logger.info(`Trying descendant XPath: ${fallbackXpath}`);
+    const fallbackCount = getTagOnlyXpathCandidateCount(fallbackXpath, element, root);
+    // logger.info(`Match count: ${fallbackCount}`);
+    if (fallbackCount === 1 &&
+        (0, exports.getFirstMatchedNode)(fallbackXpath, root) === element) {
+        // logger.info(`Selected XPath: ${fallbackXpath}`);
+        return fallbackXpath;
+    }
+    return "";
+};
+exports.getTagOnlyXPath = getTagOnlyXPath;
+const getFirstMatchedNode = (xpath, docmt) => {
+    try {
+        if (isShadowRootNode(docmt)) {
+            const { contextNode, cloneElement } = (0, exports.createShadowEvaluationContext)(docmt);
+            // const result = owner.evaluate(
+            //   xpath,
+            //   contextNode,
+            //   null,
+            //   owner.defaultView!.XPathResult.FIRST_ORDERED_NODE_TYPE,
+            //   null
+            // );
+            const result = evaluateXPath(xpath, contextNode, "first");
+            return (result.singleNodeValue || cloneElement);
+        }
+        // const result = docmt.evaluate(
+        //   xpath,
+        //   docmt,
+        //   null,
+        //   docmt.defaultView!.XPathResult.FIRST_ORDERED_NODE_TYPE,
+        //   null
+        // );
+        const result = evaluateXPath(xpath, docmt, "first");
+        return result.singleNodeValue;
+    }
+    catch (_error) {
+        logData_1.logger.error(`error in getFirstMatchedNode ${_error.message}`);
+        return null;
+    }
+};
+exports.getFirstMatchedNode = getFirstMatchedNode;
+const isExactUniqueXpath = (xpath, element, docmt) => {
+    try {
+        const { first, second } = (0, exports.evaluateXPathOnce)(xpath, docmt);
+        return !!first && !second && first === element;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isExactUniqueXpath = isExactUniqueXpath;
+const getAxisNodeTest = (element, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    return (0, exports.isSvg)(element)
+        ? `*[local-name()='${elementTagName}']`
+        : elementTagName;
+};
+exports.getAxisNodeTest = getAxisNodeTest;
+const hasAnyNumber = (value) => /\d/.test(value);
+const getUniqueNodeAnchorXpaths = (node, docmt, isTarget, platform) => {
+    if (!(node instanceof node.ownerDocument.defaultView.Element))
+        return [];
+    const seen = new Set();
+    const anchors = [];
+    const attributes = Array.from(node.attributes || []).filter((attribute) => attribute?.value &&
+        !hasAnyNumber(attribute.value) &&
+        (0, exports.checkBlockedAttributes)(attribute, node, isTarget));
+    const pushAnchor = (key, value) => {
+        if (!value || seen.has(value))
+            return;
+        seen.add(value);
+        anchors.push({ key, value });
+    };
+    //  Priority attributes
+    const priorityAttrs = [
+        "id",
+        "data-testid",
+        "data-test",
+        "data-qa",
+        "name",
+        "aria-label",
+        "role"
+    ];
+    priorityAttrs.forEach((attrName) => {
+        const attr = attributes.find((a) => a.name === attrName);
+        if (!attr)
+            return;
+        const xpath = attrName === "id"
+            ? `//*[@id='${attr.value}']`
+            : (0, exports.getXpathString)(node, attr.name, attr.value);
+        if (xpath && (0, exports.isExactUniqueXpath)(xpath, node, docmt)) {
+            pushAnchor(`anchor by ${attr.name}`, xpath);
+        }
+    });
+    //  Other attributes
+    attributes.forEach((attribute) => {
+        if (priorityAttrs.includes(attribute.name))
+            return;
+        const xpath = (0, exports.getXpathString)(node, attribute.name, attribute.value);
+        if (xpath && (0, exports.isExactUniqueXpath)(xpath, node, docmt)) {
+            pushAnchor(`anchor by ${attribute.name}`, xpath);
+        }
+    });
+    //  Text (controlled)
+    const text = node.textContent?.trim();
+    if (text && text.length < 40 && node.children.length === 0) {
+        const textXpath = (0, exports.getFilteredTextXPath)(node);
+        if (textXpath && (0, exports.isExactUniqueXpath)(textXpath, node, docmt)) {
+            pushAnchor("anchor by text", textXpath);
+        }
+    }
+    //  Combination
+    if (attributes.length > 1) {
+        const combinationXpath = (0, exports.getAttributeCombinationXpath)(node, docmt, attributes, isTarget, platform);
+        if (combinationXpath && (0, exports.isExactUniqueXpath)(combinationXpath, node, docmt)) {
+            pushAnchor("anchor by combination", combinationXpath);
+        }
+    }
+    //  Tag (last fallback)
+    const tagXpath = (0, exports.getTagOnlyXPath)(node, platform, docmt);
+    if (tagXpath && (0, exports.isExactUniqueXpath)(tagXpath, node, docmt)) {
+        pushAnchor("anchor by tag", tagXpath);
+    }
+    return anchors;
+};
+exports.getUniqueNodeAnchorXpaths = getUniqueNodeAnchorXpaths;
+const getTextXpathFunction = (domNode) => {
+    const trimmedText = (0, exports.getTextContent)(domNode)?.trim();
+    const filteredText = trimmedText
+        ? (0, exports.escapeCharacters)(deleteGarbageFromInnerText(trimmedText))
+        : trimmedText;
+    if (filteredText) {
+        if (filteredText !== `'${trimmedText}'`) {
+            return `contains(.,${filteredText})`;
+        }
+        return `normalize-space(.)='${trimmedText}'`;
+    }
+};
+exports.getTextXpathFunction = getTextXpathFunction;
+const getXpathString = (node, attrName, attrValue) => {
+    const reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+    let xpathe = "";
+    attrValue = (0, exports.sanitizeAttributeValue)(attrName, attrValue);
+    if (attrValue) {
+        if (!reWhiteSpace.test(attrValue)) {
+            xpathe = (0, exports.isSvg)(node)
+                ? `//*[local-name()='${node.tagName}' and contains(@${attrName},${(0, exports.escapeCharacters)(attrValue)})]`
+                : `//${node.tagName || "*"}[contains(@${attrName},${(0, exports.escapeCharacters)(attrValue)})]`;
+        }
+        else if (attrName === "class") {
+            xpathe = (0, exports.isSvg)(node)
+                ? `//*[local-name()='${node.tagName}' and contains(@${attrName},${(0, exports.escapeCharacters)(attrValue)})]`
+                : `//${node.tagName || "*"}[contains(@${attrName},${(0, exports.escapeCharacters)(attrValue)})]`;
+        }
+        else {
+            xpathe = (0, exports.isSvg)(node)
+                ? `//*[local-name()='${node.tagName}' and @${attrName}=${(0, exports.escapeCharacters)(attrValue)}]`
+                : `//${node.tagName || "*"}[@${attrName}=${(0, exports.escapeCharacters)(attrValue)}]`;
+        }
+    }
+    return xpathe;
+};
+exports.getXpathString = getXpathString;
+const replaceActualAttributes = (str) => {
+    if (str) {
+        return str.replace(/\bdisabled\b/gi, "flndisabled");
+    }
+    return str;
+};
+exports.replaceActualAttributes = replaceActualAttributes;
+const addAttributeSplitCombineXpaths = (attributes, targetElemt, docmt, isTarget) => {
+    const attributesArray = Array.prototype.slice.call(attributes);
+    const xpaths = [];
+    try {
+        attributesArray.map((element) => {
+            if ((0, exports.checkBlockedAttributes)(element, targetElemt, isTarget)) {
+                const xpth = (0, exports.getCombinationXpath)(element, targetElemt);
+                if (xpth) {
+                    xpaths.push({
+                        key: `split xpath by ${element.name}`,
+                        value: xpth
+                    });
+                }
+            }
+        });
+    }
+    catch (error) {
+        logData_1.logger.error(`error in addAttributeSplitCombineXpaths ${error.message}`);
+    }
+    return xpaths;
+};
+const getReferenceElementsXpath = (domNode, docmt, isTarget, platform) => {
+    let nodeXpath1;
+    const xpaths1 = [];
+    if (domNode.textContent &&
+        (!isTarget || (isTarget && !(0, exports.isNumberExist)(domNode.textContent)))) {
+        if (!exports.reWhiteSpace.test(domNode.textContent)) {
+            nodeXpath1 = (0, exports.isSvg)(domNode)
+                ? `*[local-name()='${domNode.tagName}' and ${(0, exports.getTextXpathFunction)(domNode)})]`
+                : `${domNode.tagName}[${(0, exports.getTextXpathFunction)(domNode)}]`;
+            if (nodeXpath1) {
+                xpaths1.push({ key: "getReferenceElementsXpath", value: nodeXpath1 });
+            }
+        }
+        else {
+            nodeXpath1 = (0, exports.isSvg)(domNode)
+                ? `*[local-name()='${domNode.tagName}' and .=${(0, exports.escapeCharacters)((0, exports.getTextContent)(domNode))}]`
+                : `${domNode.tagName}[.=${(0, exports.escapeCharacters)((0, exports.getTextContent)(domNode))}]`;
+            if (nodeXpath1) {
+                xpaths1.push({ key: "getReferenceElementsXpath", value: nodeXpath1 });
+            }
+        }
+    }
+    if (domNode.attributes) {
+        for (const attrName of Array.from(domNode.attributes)) {
+            if ((0, exports.checkBlockedAttributes)(attrName, domNode, isTarget)) {
+                let attrValue = attrName.nodeValue;
+                if (attrValue) {
+                    attrValue = (0, exports.sanitizeAttributeValue)(attrName.name, attrValue);
+                    const elementName = attrName.name;
+                    if (elementName === "class") {
+                        nodeXpath1 = (0, exports.isSvg)(domNode)
+                            ? `*[local-name()='${domNode.tagName}' and contains(@${elementName},${(0, exports.escapeCharacters)(attrValue)})]`
+                            : `${domNode.tagName}[contains(@${elementName},${(0, exports.escapeCharacters)(attrValue)})]`;
+                    }
+                    else {
+                        nodeXpath1 = (0, exports.isSvg)(domNode)
+                            ? `*[local-name()='${domNode.tagName}' and @${elementName}=${(0, exports.escapeCharacters)(attrValue)}]`
+                            : `${domNode.tagName}[@${elementName}=${(0, exports.escapeCharacters)(attrValue)}]`;
+                    }
+                    if (nodeXpath1) {
+                        xpaths1.push({
+                            key: "getReferenceElementsXpath",
+                            value: nodeXpath1
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (!xpaths1?.length) {
+        const attributesArray = Array.prototype.slice.call(domNode.attributes);
+        if (attributesArray?.length > 1) {
+            const combinationXpath = (0, exports.getAttributeCombinationXpath)(domNode, docmt, Array.prototype.slice.call(domNode.attributes), isTarget, platform);
+            if (combinationXpath) {
+                xpaths1.push({
+                    key: "getReferenceElementsXpath",
+                    value: combinationXpath
+                });
+            }
+        }
+    }
+    if (!xpaths1?.length) {
+        const combinePattern = [];
+        let pattern;
+        const tag = (0, exports.isSvg)(domNode);
+        if (domNode.textContent && isTarget && (0, exports.isNumberExist)(domNode.textContent)) {
+            const contentRes = [...new Set(domNode.textContent.match(/([^0-9]+)/g))];
+            if (contentRes?.length) {
+                for (let i = 0; i < contentRes?.length; i++) {
+                    if (contentRes[i] &&
+                        (0, exports.replaceWhiteSpaces)(contentRes[i].trim())?.length > 1) {
+                        if (!exports.reWhiteSpace.test(contentRes[i])) {
+                            combinePattern.push(`contains(.,${(0, exports.escapeCharacters)((0, exports.replaceWhiteSpaces)(contentRes[i])).trim()})`);
+                        }
+                        else {
+                            combinePattern.push(`contains(.,${(0, exports.escapeCharacters)(contentRes[i]).trim()})`);
+                        }
+                    }
+                }
+            }
+            if (combinePattern?.length) {
+                if (tag) {
+                    pattern = `//*[local-name()='${tag}' and ${combinePattern.join(" and ")}]`;
+                }
+                else {
+                    pattern = `//${tag}[${combinePattern.join(" and ")}]`;
+                }
+                if (pattern)
+                    xpaths1.push({ key: "getReferenceElementsXpath", value: pattern });
+            }
+        }
+    }
+    if (!xpaths1?.length) {
+        const xpaths = addAttributeSplitCombineXpaths(domNode.attributes, domNode, docmt, isTarget);
+        if (xpaths?.length) {
+            xpaths1.concat(xpaths);
+        }
+    }
+    return xpaths1;
+};
+exports.getReferenceElementsXpath = getReferenceElementsXpath;
+const normalizeXPath = (xpath) => {
+    // Replace text() = "value"  or  text()='value'
+    xpath = xpath.replace(/text\(\)\s*=\s*(['"])(.*?)\1/g, "normalize-space(.)=$1$2$1");
+    // Replace . = "value" or .='value'
+    xpath = xpath.replace(/\.\s*=\s*(['"])(.*?)\1/g, "normalize-space(.)=$1$2$1");
+    return xpath;
+};
+exports.normalizeXPath = normalizeXPath;
+const findMatchingParenthesis = (text, openPos) => {
+    let closePos = openPos;
+    let counter = 1;
+    while (counter > 0) {
+        const c = text[++closePos];
+        if (c == "(") {
+            counter++;
+        }
+        else if (c == ")") {
+            counter--;
+        }
+    }
+    return closePos;
+};
+exports.findMatchingParenthesis = findMatchingParenthesis;
+function escapeAttrValue(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/ /g, "\\ ");
+}
+function isUniqueInDOM(docmt, name, value, element) {
+    const root = element?.getRootNode?.() ?? docmt;
+    const queryAll = (selector) => {
+        try {
+            return Array.from(root.querySelectorAll(selector));
+        }
+        catch {
+            return [];
+        }
+    };
+    try {
+        switch (name) {
+            case "id":
+                return queryAll(`#${escapeAttrValue(value)}`).length === 1;
+            case "name":
+                return queryAll(`[name="${escapeAttrValue(value)}"]`).length === 1;
+            case "className":
+                return queryAll(`.${value}`).length === 1;
+            case "tagName":
+                return queryAll(value).length === 1;
+            case "linkText":
+                return (queryAll("a").filter((a) => a.textContent?.trim() === value)
+                    .length === 1);
+            case "partialLinkText":
+                return (queryAll("a").filter((a) => a.textContent?.includes(value)).length ===
+                    1);
+            case "cssSelector":
+                return queryAll(value).length === 1;
+            default:
+                return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+const getPlatformFallbackXpath = (element, platform) => {
+    const tag = element.tagName;
+    if (platform === "android") {
+        const bounds = element.getAttribute("bounds");
+        const index = element.getAttribute("index");
+        if (bounds) {
+            return index
+                ? `//${tag}[@index="${index}" and @bounds="${bounds}"]`
+                : `//${tag}[@bounds="${bounds}"]`;
+        }
+    }
+    if (platform === "ios") {
+        const name = element.getAttribute("name");
+        if (name) {
+            return `//${tag}[@name="${name}"]`;
+        }
+        const label = element.getAttribute("label");
+        if (label) {
+            return `//${tag}[@label="${label}"]`;
+        }
+        const value = element.getAttribute("value");
+        if (value) {
+            return `//${tag}[@value="${value}"]`;
+        }
+        const x = element.getAttribute("x");
+        const y = element.getAttribute("y");
+        const width = element.getAttribute("width");
+        const height = element.getAttribute("height");
+        if (x && y && width && height) {
+            return `//${tag}[@x="${x}" and @y="${y}" and @width="${width}" and @height="${height}"]`;
+        }
+    }
+    return null;
+};
+exports.getPlatformFallbackXpath = getPlatformFallbackXpath;
+exports.xpathUtils = {
+    getReferenceElementsXpath: exports.getReferenceElementsXpath,
+    getAbsoluteXPath: exports.getAbsoluteXPath,
+    getRelativeXPath: exports.getRelativeXPath,
+    getCombinationXpath: exports.getCombinationXpath,
+    getAttributeCombinationXpath: exports.getAttributeCombinationXpath,
+    isSvg: exports.isSvg,
+    getPlatformFallbackXpath: exports.getPlatformFallbackXpath,
+    findXpathWithIndex: exports.findXpathWithIndex,
+    isNumberExist: exports.isNumberExist,
+    getTextContent: exports.getTextContent,
+    getCountOfXPath: exports.getCountOfXPath,
+    normalizeXPath: exports.normalizeXPath,
+    getShadowRoot: exports.getShadowRoot,
+    escapeCharacters: exports.escapeCharacters,
+    removeParenthesis: exports.removeParenthesis,
+    checkBlockedAttributes: exports.checkBlockedAttributes,
+    getRelationship: exports.getRelationship,
+    findMatchingParenthesis: exports.findMatchingParenthesis,
+    deleteGarbageFromInnerText,
+    replaceTempAttributes: exports.replaceTempAttributes,
+    // createObserver,
+    // startObserver,
+    // stopObserver,
+    modifiedElementAttributes: exports.modifiedElementAttributes,
+    cspEnabled: exports.cspEnabled,
+    getNormalizedPropertyXPath: exports.getNormalizedPropertyXPath,
+    getStartsWithPropertyXPath: exports.getStartsWithPropertyXPath,
+    getContainsPropertyXPath: exports.getContainsPropertyXPath,
+    getOrAttributesXPath: exports.getOrAttributesXPath,
+    getTagOnlyXPath: exports.getTagOnlyXPath,
+    getFirstMatchedNode: exports.getFirstMatchedNode,
+    isExactUniqueXpath: exports.isExactUniqueXpath,
+    getAxisNodeTest: exports.getAxisNodeTest,
+    getUniqueNodeAnchorXpaths: exports.getUniqueNodeAnchorXpaths,
+    escapeAttrValue,
+    isUniqueInDOM,
+    sanitizeAttributeValue: exports.sanitizeAttributeValue
+};