ff-automationv2 2.2.28 → 2.2.30

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

@@ -0,0 +1,1628 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xpathUtils = exports.findMatchingParenthesis = exports.normalizeXPath = exports.getReferenceElementsXpath = exports.replaceAiActualAttributes = exports.getAiXpathString = exports.getAiTextXpathFunction = exports.getAiUniqueNodeAnchorXpaths = exports.getAiAxisNodeTest = exports.isAiExactUniqueXpath = exports.getAiFirstMatchedNode = exports.getAiTagOnlyXPath = exports.getOrAttributesAiXPath = exports.getAiContainsPropertyXPath = exports.getAiStartsWithPropertyXPath = exports.getAiNormalizedPropertyXPath = exports.getAiFilteredTextXPath = exports.intermediateAiXpathStep = exports.getAiAttributeCombinationXpath = exports.getAiCombinationXpath = exports.getAIRelativeXPath = exports.getAiAbsoluteXPath = exports.getAiPropertyXPath = exports.replaceAiTempAttributes = exports.isAiSvg = exports.getAiRelationship = exports.checkAiBlockedAttributes = exports.createAIShadowEvaluationContext = exports.getAiShadowRoot = exports.aiReplaceWhiteSpaces = exports.findAiXpathWithIndex = exports.removeAiParenthesis = exports.escapeAiCharacters = exports.getAiCountOfXPath = exports.getAiFilteredText = exports.getAiTextContent = exports.buildAiPattern = exports.isAiNumberExist = exports.sanitizeAiAttributeValue = exports.modifiedElementAttributes = exports.evaluateAIXPathOnce = exports.clearAiXPathEvalCache = exports.timeLog = exports.cspEnabled = exports.reWhiteSpace = void 0;
+exports.evaluateAiXPath = evaluateAiXPath;
+exports.escapeAttrValue = escapeAttrValue;
+exports.isAiUniqueInDOM = isAiUniqueInDOM;
+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 XPathResultConst = {
+    ANY_TYPE: 0,
+    NUMBER_TYPE: 1,
+    STRING_TYPE: 2,
+    BOOLEAN_TYPE: 3,
+    UNORDERED_NODE_ITERATOR_TYPE: 4,
+    ORDERED_NODE_ITERATOR_TYPE: 5,
+    UNORDERED_NODE_SNAPSHOT_TYPE: 6,
+    ORDERED_NODE_SNAPSHOT_TYPE: 7,
+    ANY_UNORDERED_NODE_TYPE: 8,
+    FIRST_ORDERED_NODE_TYPE: 9
+};
+const getAiXPathContext = (docmt) => {
+    const owner = docmt.nodeType === 9
+        ? docmt
+        : docmt.ownerDocument;
+    // 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 getAiMutationCacheContexts = (node) => {
+    const contexts = [];
+    const addAiContext = (candidate) => {
+        if (!candidate || contexts.includes(candidate))
+            return;
+        contexts.push(candidate);
+    };
+    addAiContext(node);
+    const rootNode = node.getRootNode?.();
+    if (rootNode && (rootNode.nodeType === 9 || rootNode.nodeType === 11)) {
+        addAiContext(rootNode);
+    }
+    const ownerDocument = node.nodeType === 9
+        ? node
+        : node.ownerDocument;
+    addAiContext(ownerDocument);
+    return contexts;
+};
+const clearAiXPathEvalCache = (node) => {
+    if (!node) {
+        xpathEvalCache = new WeakMap();
+        return;
+    }
+    getAiMutationCacheContexts(node).forEach((contextNode) => {
+        xpathEvalCache.delete(contextNode);
+    });
+};
+exports.clearAiXPathEvalCache = clearAiXPathEvalCache;
+function svgAiXPathFallback(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 evaluateAiXPath(xpath, contextNode, mode = "iterator") {
+    const owner = contextNode.nodeType === 9
+        ? contextNode
+        : contextNode.ownerDocument;
+    try {
+        const resultType = mode === "first"
+            ? (owner.defaultView?.XPathResult?.FIRST_ORDERED_NODE_TYPE ?? XPathResultConst.FIRST_ORDERED_NODE_TYPE)
+            : mode === "snapshot"
+                ? (owner.defaultView?.XPathResult?.ORDERED_NODE_SNAPSHOT_TYPE ?? XPathResultConst.ORDERED_NODE_SNAPSHOT_TYPE)
+                : (owner.defaultView?.XPathResult?.ORDERED_NODE_ITERATOR_TYPE ?? XPathResultConst.ORDERED_NODE_ITERATOR_TYPE);
+        return owner.evaluate(xpath, contextNode, null, resultType, null);
+    }
+    catch (e) {
+        logData_1.logger.error(` Error in evaluating xpath: ${e.message}`);
+        const root = contextNode.nodeType === 9
+            ? contextNode
+            : contextNode.ownerDocument;
+        const nodes = svgAiXPathFallback(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 evaluateAIXPathOnce = (xpath, docmt) => {
+    try {
+        const contextNode = getAiXPathContext(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 = evaluateAiXPath(xpath, contextNode);
+        const owner = contextNode.nodeType === 9
+            ? contextNode
+            : contextNode.ownerDocument;
+        // const result = owner.evaluate(
+        //   xpath,
+        //   contextNode,
+        //   null,
+        //   owner.defaultView!.XPathResult.ORDERED_NODE_ITERATOR_TYPE,
+        //   null
+        // );
+        let result;
+        try {
+            const iteratorType = owner.defaultView?.XPathResult?.ORDERED_NODE_ITERATOR_TYPE ??
+                XPathResultConst.ORDERED_NODE_ITERATOR_TYPE;
+            result = owner.evaluate(xpath, contextNode, null, iteratorType, null);
+        }
+        catch (err) {
+            logData_1.logger.error("evaluate exception", err);
+            return { first: null, second: null };
+        }
+        const first = result.iterateNext();
+        const second = result.iterateNext();
+        const evalResult = { first, second };
+        nodeCache.set(xpath, evalResult);
+        return evalResult;
+    }
+    catch (e) {
+        logData_1.logger.error(e);
+        return { first: null, second: null };
+    }
+};
+exports.evaluateAIXPathOnce = evaluateAIXPathOnce;
+const relativeXPathCache = new Map();
+exports.modifiedElementAttributes = [];
+const INTERNAL_CLASS_TOKENS = new Set([
+    "marked-element-temp",
+    "removePointers"
+]);
+const normalizeAiClassTokens = (classValue) => (classValue || "")
+    .split(/\s+/)
+    .map((token) => token.trim())
+    .filter((token) => token && !INTERNAL_CLASS_TOKENS.has(token))
+    .sort();
+const sanitizeAiAttributeValue = (attributeName, attributeValue) => {
+    if (!attributeValue) {
+        return "";
+    }
+    if (attributeName === "class" || attributeName === "className") {
+        return normalizeAiClassTokens(attributeValue).join(" ");
+    }
+    return attributeValue.replace("removePointers", "").trim();
+};
+exports.sanitizeAiAttributeValue = sanitizeAiAttributeValue;
+const isAiNumberExist = (str) => {
+    const hasNumber = /\d/;
+    return hasNumber.test(str);
+};
+exports.isAiNumberExist = isAiNumberExist;
+const buildAiPattern = (pattern, isAiSvg, tagName) => {
+    return isAiSvg
+        ? `//*[local-name()='${tagName}' and ${pattern}]`
+        : `//${tagName}[${pattern}]`;
+};
+exports.buildAiPattern = buildAiPattern;
+const getAiTextContent = (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.getAiTextContent = getAiTextContent;
+const getAiFilteredText = (element) => {
+    return element?.childNodes[0]?.nodeValue || "";
+};
+exports.getAiFilteredText = getAiFilteredText;
+const getAiCountOfXPath = (xpath, element, docmt, multiElementReferenceMode = false) => {
+    try {
+        const { first, second } = (0, exports.evaluateAIXPathOnce)(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 = evaluateAiXPath(xpath, docmt);
+            let node;
+            while ((node = result.iterateNext())) {
+                if (element.includes(node)) {
+                    matchCount++;
+                    if (matchCount === 2)
+                        return 2;
+                }
+            }
+            return 0;
+        }
+        return 2;
+    }
+    catch {
+        return 0;
+    }
+};
+exports.getAiCountOfXPath = getAiCountOfXPath;
+const escapeAiCharacters = (text) => {
+    if (text) {
+        if (!(text.indexOf('"') === -1)) {
+            return `'${text}'`;
+        }
+        if (!(text.indexOf("'") === -1)) {
+            return `"${text}"`;
+        }
+    }
+    return `'${text}'`;
+};
+exports.escapeAiCharacters = escapeAiCharacters;
+const removeAiParenthesis = (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.removeAiParenthesis = removeAiParenthesis;
+const findAiXpathWithIndex = (val, node, docmt, count) => {
+    try {
+        let index = 0;
+        if (count) {
+            if ((0, exports.getAiCountOfXPath)(`${val}[${count}]`, node, docmt) === 1) {
+                return `${val}[${count}]`;
+            }
+            if ((0, exports.getAiCountOfXPath)(`(${val})[${count}]`, node, docmt) === 1) {
+                return `(${val})[${count}]`;
+            }
+        }
+        // const nodes = owner.evaluate(val, docmt, null, owner.defaultView!.XPathResult.ANY_TYPE, null);
+        const nodes = evaluateAiXPath(val, docmt);
+        let nodex = null;
+        while ((nodex = nodes.iterateNext())) {
+            index++;
+            if (nodex.isSameNode(node)) {
+                if ((0, exports.getAiCountOfXPath)(`${val}[${index}]`, node, docmt) === 1) {
+                    return `${val}[${index}]`;
+                }
+                if ((0, exports.getAiCountOfXPath)(`(${val})[${index}]`, node, docmt) === 1) {
+                    return `(${val})[${index}]`;
+                }
+                return;
+            }
+        }
+    }
+    catch (error) {
+        logData_1.logger.error(error);
+    }
+};
+exports.findAiXpathWithIndex = findAiXpathWithIndex;
+const deleteAiLineGap = (a) => {
+    a && (a = a.split("\n")[0].length > 0 ? a.split("\n")[0] : a.split("\n")[1]);
+    return a;
+};
+const deleteAiGarbageFromInnerText = (a) => {
+    a = deleteAiLineGap(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 aiReplaceWhiteSpaces = (str) => {
+    if (str) {
+        return str.replace(/\s\s+/g, " ").trim();
+    }
+    return str;
+};
+exports.aiReplaceWhiteSpaces = aiReplaceWhiteSpaces;
+const getAiShadowRoot = (el) => {
+    if (!el || !el?.getRootNode)
+        return null;
+    const root = el.getRootNode();
+    return root && root?.host ? root : null;
+};
+exports.getAiShadowRoot = getAiShadowRoot;
+const isAiShadowRootNode = (node) => {
+    return node?.nodeType === 11 && "host" in node;
+};
+const getAiElementPathFromRoot = (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 getAiElementAtPath = (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 createAIShadowEvaluationContext = (root, element) => {
+    const tempDoc = root.ownerDocument.implementation.createHTMLDocument("shadow-xpath");
+    const wrapper = tempDoc.createElement("div");
+    wrapper.innerHTML = root.innerHTML;
+    tempDoc.body.appendChild(wrapper);
+    const cloneAiForElement = (candidate) => {
+        if (!candidate ||
+            candidate.nodeType !== 1) {
+            return null;
+        }
+        const path = getAiElementPathFromRoot(root, candidate);
+        return path ? getAiElementAtPath(wrapper, path) : null;
+    };
+    const cloneElements = Array.isArray(element)
+        ? element.map((candidate) => cloneAiForElement(candidate)).filter(Boolean)
+        : [];
+    const cloneElement = Array.isArray(element)
+        ? null
+        : cloneAiForElement(element ?? null);
+    return {
+        contextNode: wrapper,
+        cloneElement,
+        cloneElements
+    };
+};
+exports.createAIShadowEvaluationContext = createAIShadowEvaluationContext;
+const checkAiBlockedAttributes = (attribute, targetElement, isTarget) => {
+    const sanitizedValue = (0, exports.sanitizeAiAttributeValue)(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.isAiNumberExist)(sanitizedValue)) {
+        return false;
+    }
+    return true;
+};
+exports.checkAiBlockedAttributes = checkAiBlockedAttributes;
+const getAiRelationship = (a, b) => {
+    const pos = a.compareDocumentPosition(b);
+    return pos === 2
+        ? "preceding"
+        : pos === 4
+            ? "following"
+            : pos === 8
+                ? "ancestor"
+                : pos === 16
+                    ? "descendant"
+                    : pos === 32
+                        ? "self"
+                        : "";
+};
+exports.getAiRelationship = getAiRelationship;
+const isAiSvg = (element) => {
+    if (!element || element.nodeType !== 1)
+        return false;
+    const svgClass = element.ownerDocument?.defaultView?.SVGElement;
+    if (svgClass && element instanceof svgClass)
+        return true;
+    return element.tagName?.toLowerCase() === "svg" || element.namespaceURI === "http://www.w3.org/2000/svg";
+};
+exports.isAiSvg = isAiSvg;
+const replaceAiTempAttributes = (str) => {
+    if (!str)
+        return str;
+    return str.replace(/\b[a-zA-Z_]*disabled\b/gi, "disabled");
+};
+exports.replaceAiTempAttributes = replaceAiTempAttributes;
+const getAiPropertyXPath = (element, docmt, prop, value, isTarget, platform) => {
+    if (value) {
+        const { tagName } = element;
+        let count;
+        let combinePattern = "";
+        const mergePattern = [];
+        let pattern;
+        let elementTagName = element.tagName;
+        if (value && (!isTarget || !(0, exports.isAiNumberExist)(value))) {
+            if (!exports.reWhiteSpace.test(value)) {
+                if (platform == 'web') {
+                    elementTagName = element.tagName.toLowerCase();
+                }
+                pattern = (0, exports.buildAiPattern)(`normalize-space(${prop})=${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(value)).trim()}`, (0, exports.isAiSvg)(element), elementTagName);
+            }
+            else {
+                pattern = `//${elementTagName}[${prop}=${(0, exports.escapeAiCharacters)(value)}]`;
+            }
+            count = (0, exports.getAiCountOfXPath)(pattern, element, docmt);
+            if (count === 1) {
+                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.aiReplaceWhiteSpaces)(contentRes[0].trim())?.length > 1) {
+                            if (value.startsWith(contentRes[0])) {
+                                if (!exports.reWhiteSpace.test(contentRes[0])) {
+                                    combinePattern = `starts-with(${prop},${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(contentRes[0])).trim()})`;
+                                }
+                                else {
+                                    combinePattern = `starts-with(${prop},${(0, exports.escapeAiCharacters)(contentRes[0]).trim()})`;
+                                }
+                            }
+                        }
+                    }
+                    if (contentRes?.length > 1) {
+                        if (contentRes[contentRes.length - 1] &&
+                            (0, exports.aiReplaceWhiteSpaces)(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.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(contentRes[contentRes.length - 1])).trim()})`;
+                                }
+                                else {
+                                    combinePattern = `ends-with(${prop},${(0, exports.escapeAiCharacters)(contentRes[contentRes.length - 1]).trim()})`;
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        if ((0, exports.isAiSvg)(element)) {
+                            pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                        }
+                        else {
+                            pattern = `//${tagName}[${combinePattern}]`;
+                        }
+                        count = (0, exports.getAiCountOfXPath)(pattern, element, docmt);
+                        if (count === 1) {
+                            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.aiReplaceWhiteSpaces)(contentRes[0].trim())?.length) {
+                            if (value.startsWith(contentRes[0])) {
+                                if (!exports.reWhiteSpace.test(contentRes[0])) {
+                                    combinePattern = `starts-with(${prop},${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(contentRes[0])).trim()})`;
+                                }
+                                else {
+                                    combinePattern = `starts-with(${prop},${(0, exports.escapeAiCharacters)(contentRes[0]).trim()})`;
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        if ((0, exports.isAiSvg)(element)) {
+                            pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                        }
+                        else {
+                            pattern = `//${tagName}[${combinePattern}]`;
+                        }
+                        count = (0, exports.getAiCountOfXPath)(pattern, element, docmt);
+                        if (count === 1) {
+                            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.aiReplaceWhiteSpaces)(contentRes[0].trim())?.length > 3) {
+                            if (value.endsWith(contentRes[0])) {
+                                if (!exports.reWhiteSpace.test(contentRes[0])) {
+                                    combinePattern = `ends-with(${prop},${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(contentRes[0])).trim()})`;
+                                }
+                                else {
+                                    combinePattern = `ends-with(${prop},${(0, exports.escapeAiCharacters)(contentRes[0]).trim()})`;
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        if ((0, exports.isAiSvg)(element)) {
+                            pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                        }
+                        else {
+                            pattern = `//${tagName}[${combinePattern}]`;
+                        }
+                        count = (0, exports.getAiCountOfXPath)(pattern, element, docmt);
+                        if (count === 1) {
+                            return pattern;
+                        }
+                    }
+                }
+            }
+        }
+        if (value && isTarget && (0, exports.isAiNumberExist)(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.aiReplaceWhiteSpaces)(contentRes[i].trim())?.length > 1) {
+                        if (!exports.reWhiteSpace.test(contentRes[i])) {
+                            mergePattern.push(`contains(${prop},${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(contentRes[i])).trim()})`);
+                        }
+                        else {
+                            mergePattern.push(`contains(${prop},${(0, exports.escapeAiCharacters)(contentRes[i].trim()).trim()})`);
+                        }
+                    }
+                }
+            }
+            if (mergePattern?.length) {
+                if ((0, exports.isAiSvg)(element)) {
+                    pattern = `//*[local-name()='${tagName}' and ${mergePattern.join(" and ")}]`;
+                }
+                else {
+                    pattern = `//${tagName}[${mergePattern.join(" and ")}]`;
+                }
+                count = (0, exports.getAiCountOfXPath)(pattern, element, docmt);
+                if (count === 1) {
+                    return pattern;
+                }
+            }
+        }
+        if ((0, exports.isAiSvg)(element)) {
+            pattern = `//*[local-name()='${tagName}' and text()]`;
+        }
+        else {
+            pattern = `//${tagName}[text()]`;
+        }
+        count = (0, exports.getAiCountOfXPath)(pattern, element, docmt);
+        if (count === 1) {
+            return pattern;
+        }
+    }
+};
+exports.getAiPropertyXPath = getAiPropertyXPath;
+const getAiAbsoluteXPath = (domNode, docmt) => {
+    try {
+        if (!domNode || domNode.nodeType !== 1) {
+            return "";
+        }
+        let xpathe = (0, exports.isAiSvg)(domNode)
+            ? `/*[local-name()='${domNode.tagName}']`
+            : `/${domNode.tagName}`;
+        // // If this node has siblings of the same tagName, get the index of this node
+        const parent = domNode.parentElement || domNode.parentNode;
+        if (parent && parent.nodeType === 1) {
+            // Get the siblings
+            const childNodes = Array.prototype.slice
+                .call(parent.children || parent.childNodes, 0)
+                .filter((childNode) => childNode && childNode.nodeType === 1 && 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
+        const parentNode = domNode.parentElement || domNode.parentNode;
+        if (parentNode && parentNode.nodeType === 1) {
+            return (0, exports.getAiAbsoluteXPath)(parentNode, docmt) + xpathe;
+        }
+        return xpathe;
+    }
+    catch (error) {
+        // If there's an unexpected exception, abort and don't get an XPath
+        logData_1.logger.error("xpath", error);
+        return "";
+    }
+};
+exports.getAiAbsoluteXPath = getAiAbsoluteXPath;
+const getAIRelativeXPath = (domNode, docmt, _isTarget = false, attributesArray, platform = "web") => {
+    try {
+        if (!domNode || domNode.nodeType !== 1) {
+            return null;
+        }
+        // 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;
+        let hasUniqueAttr = false;
+        // Traverse up the DOM tree iteratively instead of using recursion
+        while (currentNode && currentNode.nodeType === 1) {
+            const isTargetNode = domNode === currentNode;
+            const attributes = isTargetNode
+                ? (attributesArray ?? Array.from(currentNode.attributes))
+                : Array.from(currentNode.attributes);
+            // Loop through attributes to check for unique identifiers
+            for (const attrName of attributes) {
+                const checkTarget = platform === "android" ? true : (isTargetNode ? _isTarget : false);
+                if ((0, exports.checkAiBlockedAttributes)(attrName, currentNode, checkTarget)) {
+                    const attrValue = (0, exports.sanitizeAiAttributeValue)(attrName.name, attrName.nodeValue);
+                    if (platform === "android" && attrValue && (0, exports.isAiNumberExist)(attrValue)) {
+                        continue;
+                    }
+                    const elementName = attrName.name;
+                    // Construct an XPath based on attribute
+                    const xpathe = (0, exports.getAiXpathString)(currentNode, elementName, attrValue);
+                    if (xpathe) {
+                        const othersWithAttr = (0, exports.getAiCountOfXPath)(xpathe, currentNode, docmt);
+                        if (othersWithAttr === 1) {
+                            xpathParts.unshift((0, exports.replaceAiTempAttributes)(xpathe));
+                            hasUniqueAttr = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (hasUniqueAttr) {
+                break;
+            }
+            if (currentNode.textContent) {
+                const canCheckText = platform === "android"
+                    ? !(0, exports.isAiNumberExist)(currentNode.textContent)
+                    : (!isTargetNode || !_isTarget || !(0, exports.isAiNumberExist)(currentNode.textContent));
+                if (canCheckText) {
+                    const reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+                    const filteredText = (0, exports.getAiFilteredText)(currentNode);
+                    if (filteredText && (platform !== "android" || !(0, exports.isAiNumberExist)(filteredText))) {
+                        let xpathe = "";
+                        if (!reWhiteSpace.test(currentNode.textContent)) {
+                            xpathe = (0, exports.isAiSvg)(currentNode)
+                                ? `//*[local-name()='${currentNode.tagName}' and normalize-space(.)=${(0, exports.escapeAiCharacters)(filteredText)}]`
+                                : `//${currentNode.tagName || "*"}[normalize-space(.)=${(0, exports.escapeAiCharacters)(filteredText)}]`;
+                        }
+                        else {
+                            xpathe = (0, exports.isAiSvg)(currentNode)
+                                ? `//*[local-name()='${currentNode.tagName}' and .=${(0, exports.escapeAiCharacters)(filteredText)}]`
+                                : `//${currentNode.tagName || "*"}[.=${(0, exports.escapeAiCharacters)(filteredText)}]`;
+                        }
+                        const othersWithAttr = (0, exports.getAiCountOfXPath)(xpathe, currentNode, docmt);
+                        if (othersWithAttr === 1) {
+                            xpathParts.unshift((0, exports.replaceAiTempAttributes)(xpathe));
+                            hasUniqueAttr = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            // If no unique attribute was found, construct XPath by tag name
+            const currentTag = currentNode.tagName;
+            const currentEl = currentNode;
+            let tagBasedXPath = (0, exports.isAiSvg)(currentNode)
+                ? `/*[local-name()='${currentTag}']`
+                : `/${currentTag}`;
+            // Handle sibling nodes
+            const parent = currentNode.parentElement || currentNode.parentNode;
+            if (parent && parent.nodeType === 1) {
+                const siblings = Array.from(parent.children || parent.childNodes).filter((childNode) => childNode && childNode.nodeType === 1 && childNode.tagName === currentTag);
+                // Append index to distinguish between siblings
+                if (siblings.length > 1) {
+                    const index = siblings.indexOf(currentEl);
+                    tagBasedXPath += `[${index + 1}]`;
+                }
+            }
+            // Add the constructed tag-based XPath to the parts array
+            xpathParts.unshift(tagBasedXPath);
+            // Move up to the parent node for the next iteration
+            currentNode = parent;
+        }
+        // Combine all parts into the final XPath
+        const finalXPath = xpathParts.join("");
+        if (finalXPath && finalXPath.startsWith("//")) {
+            const count = (0, exports.getAiCountOfXPath)(finalXPath, domNode, docmt);
+            if (count === 1) {
+                relativeXPathCache.set(domNode, finalXPath);
+                return finalXPath;
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        logData_1.logger.error("error in getAIRelativeXPath", error);
+        return null;
+    }
+};
+exports.getAIRelativeXPath = getAIRelativeXPath;
+const getAiCombinationXpath = (attribute, domNode) => {
+    const combinePattern = [];
+    let pattern;
+    if (attribute &&
+        !(0, exports.isAiNumberExist)(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.aiReplaceWhiteSpaces)(contentRes[i].trim())?.length > 2) {
+                    if (!exports.reWhiteSpace.test(contentRes[i])) {
+                        combinePattern.push(`contains(@${attribute.name},${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(contentRes[i])).trim()})`);
+                    }
+                    else {
+                        combinePattern.push(`contains(@${attribute.name},${(0, exports.escapeAiCharacters)(contentRes[i].trim())})`);
+                    }
+                }
+            }
+        }
+        if (combinePattern?.length) {
+            pattern = (0, exports.isAiSvg)(domNode)
+                ? `//*[local-name()='${domNode.tagName}' and ${combinePattern.join(" and ")}]`
+                : `//${domNode.tagName}[${combinePattern.join(" and ")}]`;
+            return pattern;
+        }
+    }
+};
+exports.getAiCombinationXpath = getAiCombinationXpath;
+const getAiAttributeCombinationXpath = (domNode, docmt, uniqueAttributes, isTarget, platform) => {
+    try {
+        const candidateAttributes = uniqueAttributes.filter((attr) => (0, exports.checkAiBlockedAttributes)(attr, domNode, isTarget));
+        const buildAiAttributeConditions = (attribute) => {
+            const attrValue = (0, exports.sanitizeAiAttributeValue)(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.buildAiPattern)(`contains(@class,${(0, exports.escapeAiCharacters)(token)})`, (0, exports.isAiSvg)(domNode), platform === "web" ? domNode.tagName.toLowerCase() : domNode.localName);
+                    return {
+                        token,
+                        count: getAiTagOnlyXpathCandidateCount(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.escapeAiCharacters)(rankedTokens[0].token)})`]
+                    : [];
+            }
+            if (!exports.reWhiteSpace.test(attrValue)) {
+                return [`normalize-space(@${attribute.name})="${attrValue}"`];
+            }
+            return [`@${attribute.name}="${attrValue}"`];
+        };
+        const getAiTextConditions = () => {
+            const rawText = (0, exports.aiReplaceWhiteSpaces)((0, exports.getAiTextContent)(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.escapeAiCharacters)(rawText)}`);
+            }
+            if (rawText.includes(" ")) {
+                conditions.add(`normalize-space(text())=${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(rawText))}`);
+            }
+            conditions.add(`contains(text(),${(0, exports.escapeAiCharacters)(rawText)})`);
+            return Array.from(conditions);
+        };
+        const generateAiAttributeCombinations = (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 buildAiXPath = (conditions) => (0, exports.isAiSvg)(domNode)
+            ? `//*[local-name()='${domNode.tagName}' and ${conditions.join(" and ")}]`
+            : `//${domNode.tagName}[${conditions.join(" and ")}]`;
+        const tryAiAttributeOnlyCombinations = () => {
+            if (candidateAttributes.length < 2) {
+                return undefined;
+            }
+            const maxCombinationSize = Math.min(2, candidateAttributes.length);
+            for (let combinationSize = 2; combinationSize <= maxCombinationSize; combinationSize++) {
+                const attributeGroups = generateAiAttributeCombinations(candidateAttributes, combinationSize);
+                for (const attributeGroup of attributeGroups) {
+                    const xpathConditions = [];
+                    for (const attribute of attributeGroup) {
+                        const attributeConditions = buildAiAttributeConditions(attribute);
+                        if (!attributeConditions.length)
+                            continue;
+                        xpathConditions.push(...attributeConditions);
+                    }
+                    if (xpathConditions.length < 2)
+                        continue;
+                    const xpath = buildAiXPath(xpathConditions);
+                    let matchCount;
+                    try {
+                        matchCount = (0, exports.getAiCountOfXPath)(xpath, domNode, docmt);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (matchCount === 1) {
+                        return xpath;
+                    }
+                }
+            }
+            return undefined;
+        };
+        const attributeOnlyXpath = tryAiAttributeOnlyCombinations();
+        if (attributeOnlyXpath) {
+            return attributeOnlyXpath;
+        }
+        const textConditions = getAiTextConditions();
+        if (!textConditions.length || !candidateAttributes.length) {
+            return;
+        }
+        const maxCombinationSize = Math.min(2, candidateAttributes.length);
+        for (let combinationSize = 1; combinationSize <= maxCombinationSize; combinationSize++) {
+            const attributeGroups = generateAiAttributeCombinations(candidateAttributes, combinationSize);
+            for (const attributeGroup of attributeGroups) {
+                const attributeConditions = [];
+                for (const attribute of attributeGroup) {
+                    attributeConditions.push(...buildAiAttributeConditions(attribute));
+                }
+                if (!attributeConditions.length) {
+                    continue;
+                }
+                for (const textCondition of textConditions) {
+                    const xpathConditions = [...attributeConditions, textCondition];
+                    const xpath = buildAiXPath(xpathConditions);
+                    try {
+                        if ((0, exports.getAiCountOfXPath)(xpath, domNode, docmt) === 1) {
+                            return xpath;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logData_1.logger.error(`XPath generation error: ${JSON.stringify(error, null, 2)}`);
+    }
+};
+exports.getAiAttributeCombinationXpath = getAiAttributeCombinationXpath;
+const intermediateAiXpathStep = (targetElemt, attr, isTarget) => {
+    const isSvgElement = (0, exports.isAiSvg)(targetElemt);
+    let expression = "";
+    if ((0, exports.checkAiBlockedAttributes)(attr, targetElemt, isTarget)) {
+        const attrValue = (0, exports.sanitizeAiAttributeValue)(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.escapeAiCharacters)(attrValue)}]`
+                : `${targetElemt.tagName || "*"}[normalize-space(@${elementName})=${(0, exports.escapeAiCharacters)(attrValue)}]`;
+        }
+        else {
+            expression = isSvgElement
+                ? `*[local-name()='${targetElemt.tagName}' and @${elementName}=${(0, exports.escapeAiCharacters)(attrValue)}]`
+                : `${targetElemt.tagName || "*"}[@${elementName}=${(0, exports.escapeAiCharacters)(attrValue)}]`;
+        }
+    }
+    return expression;
+};
+exports.intermediateAiXpathStep = intermediateAiXpathStep;
+const getAiFilteredTextXPath = (node) => {
+    if (!node.textContent)
+        return "";
+    const filteredText = (0, exports.getAiFilteredText)(node);
+    let xpathe;
+    if (!exports.reWhiteSpace.test(filteredText)) {
+        xpathe = (0, exports.isAiSvg)(node)
+            ? `//*[local-name()='${node.tagName}' and normalize-space(.)=${(0, exports.escapeAiCharacters)(filteredText)}]`
+            : `//${node.tagName || "*"}[normalize-space(.)=${(0, exports.escapeAiCharacters)(filteredText)}]`;
+    }
+    else {
+        xpathe = (0, exports.isAiSvg)(node)
+            ? `//*[local-name()='${node.tagName}' and .=${(0, exports.escapeAiCharacters)(filteredText)}]`
+            : `//${node.tagName || "*"}[.=${(0, exports.escapeAiCharacters)(filteredText)}]`;
+    }
+    return xpathe;
+};
+exports.getAiFilteredTextXPath = getAiFilteredTextXPath;
+const getAiNormalizedPropertyXPath = (element, prop, value, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const xpath = (0, exports.buildAiPattern)(`normalize-space(${prop})=${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(value)).trim()}`, (0, exports.isAiSvg)(element), elementTagName);
+    // logger.info("normalizedPropertyXPath", xpath)
+    return xpath;
+};
+exports.getAiNormalizedPropertyXPath = getAiNormalizedPropertyXPath;
+const getAiStartsWithPropertyXPath = (element, prop, value, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const xpath = (0, exports.buildAiPattern)(`starts-with(${prop},${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(value)).trim()})`, (0, exports.isAiSvg)(element), elementTagName);
+    // logger.info("getAiStartsWithPropertyXPath", xpath)
+    return xpath;
+};
+exports.getAiStartsWithPropertyXPath = getAiStartsWithPropertyXPath;
+const getAiContainsPropertyXPath = (element, prop, value, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const xpath = (0, exports.buildAiPattern)(`contains(${prop},${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(value)).trim()})`, (0, exports.isAiSvg)(element), elementTagName);
+    // logger.info("getAiContainsPropertyXPath", xpath)
+    return xpath;
+};
+exports.getAiContainsPropertyXPath = getAiContainsPropertyXPath;
+const getOrAttributesAiXPath = (element, attributes, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const buildAiAttributeCondition = (attribute) => {
+        const attrValue = (0, exports.sanitizeAiAttributeValue)(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.buildAiPattern)(`contains(@class,${(0, exports.escapeAiCharacters)(token)})`, (0, exports.isAiSvg)(element), elementTagName);
+                return {
+                    token,
+                    count: getAiTagOnlyXpathCandidateCount(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.escapeAiCharacters)(rankedToken)})`
+                : null;
+        }
+        if (!exports.reWhiteSpace.test(attrValue)) {
+            return `normalize-space(@${attribute.name})=${(0, exports.escapeAiCharacters)(attrValue)}`;
+        }
+        return `@${attribute.name}=${(0, exports.escapeAiCharacters)(attrValue)}`;
+    };
+    const buildTextCondition = () => {
+        const rawText = (0, exports.aiReplaceWhiteSpaces)((0, exports.getAiTextContent)(element)?.trim() || "");
+        if (!rawText || rawText.length > 80 || /^\d+$/.test(rawText)) {
+            return null;
+        }
+        if (exports.reWhiteSpace.test(rawText) && rawText.length <= 40) {
+            return `text()=${(0, exports.escapeAiCharacters)(rawText)}`;
+        }
+        if (rawText.includes(" ")) {
+            return `normalize-space(text())=${(0, exports.escapeAiCharacters)(rawText)}`;
+        }
+        return `contains(text(),${(0, exports.escapeAiCharacters)(rawText)})`;
+    };
+    const attributeConditions = attributes
+        .map((attribute) => buildAiAttributeCondition(attribute))
+        .filter(Boolean);
+    if (attributeConditions.length >= 2) {
+        return (0, exports.buildAiPattern)(`${attributeConditions[0]} or ${attributeConditions[1]}`, (0, exports.isAiSvg)(element), elementTagName);
+    }
+    const textCondition = buildTextCondition();
+    if (attributeConditions.length === 1 && textCondition) {
+        return (0, exports.buildAiPattern)(`${attributeConditions[0]} or ${textCondition}`, (0, exports.isAiSvg)(element), elementTagName);
+    }
+    return "";
+};
+exports.getOrAttributesAiXPath = getOrAttributesAiXPath;
+const getAiTagOnlyXpathCandidateCount = (xpath, element, docmt) => {
+    try {
+        return (0, exports.getAiCountOfXPath)(xpath, element, docmt);
+    }
+    catch (_error) {
+        logData_1.logger.error(`error in getAiTagOnlyXpathCandidateCount ${_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.isAiExactUniqueXpath)(xpath, node, docmt)) {
+            seen.add(xpath);
+            anchors.push(xpath);
+        }
+    };
+    orderedAttributes.forEach((attr) => {
+        if (!(0, exports.checkAiBlockedAttributes)(attr, node, false))
+            return;
+        const xpath = attr.name === "id"
+            ? `//*[@id=${(0, exports.escapeAiCharacters)((0, exports.sanitizeAiAttributeValue)(attr.name, attr.value))}]`
+            : (0, exports.getAiXpathString)(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.getAiFilteredTextXPath)(node);
+        if (textXpath) {
+            pushAnchor(textXpath);
+        }
+    }
+    if (attributes.length > 1) {
+        const combinationXpath = (0, exports.getAiAttributeCombinationXpath)(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.getAiAxisNodeTest)(current, platform));
+        current = current.parentElement;
+    }
+    return current === ancestor ? steps.join("/") : "";
+};
+const getAiTagOnlyXPath = (element, platform, docmt) => {
+    const root = docmt ??
+        (element.getRootNode?.() ||
+            element.ownerDocument);
+    const tagName = (0, exports.getAiAxisNodeTest)(element, platform);
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    const fallbackXpath = (0, exports.isAiSvg)(element)
+        ? `//*[local-name()='${elementTagName}']`
+        : `//${elementTagName}`;
+    let depth = 0;
+    for (let ancestor = element.parentElement; ancestor && depth < 5; ancestor = ancestor.parentElement,
+        depth++) {
+        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 { first, second } = (0, exports.evaluateAIXPathOnce)(descendantXpath, root);
+            if (first === element && !second) {
+                return descendantXpath;
+            }
+            const structuralPath = getStructuralPathFromAncestor(ancestor, element, platform);
+            if (structuralPath) {
+                const parentChainXpath = `${ancestorXpath}/${structuralPath}`;
+                // logger.info(`Trying descendant XPath: ${parentChainXpath}`);
+                const { first, second } = (0, exports.evaluateAIXPathOnce)(parentChainXpath, root);
+                if (first === element && !second) {
+                    return parentChainXpath;
+                }
+            }
+        }
+    }
+    // logger.info(`Trying descendant XPath: ${fallbackXpath}`);
+    const { first, second } = (0, exports.evaluateAIXPathOnce)(fallbackXpath, root);
+    if (first === element && !second) {
+        return fallbackXpath;
+    }
+    return "";
+};
+exports.getAiTagOnlyXPath = getAiTagOnlyXPath;
+const getAiFirstMatchedNode = (xpath, docmt) => {
+    try {
+        if (isAiShadowRootNode(docmt)) {
+            const { contextNode, cloneElement } = (0, exports.createAIShadowEvaluationContext)(docmt);
+            // const result = owner.evaluate(
+            //   xpath,
+            //   contextNode,
+            //   null,
+            //   owner.defaultView!.XPathResult.FIRST_ORDERED_NODE_TYPE,
+            //   null
+            // );
+            const result = evaluateAiXPath(xpath, contextNode, "first");
+            return (result.singleNodeValue || cloneElement);
+        }
+        // const result = docmt.evaluate(
+        //   xpath,
+        //   docmt,
+        //   null,
+        //   docmt.defaultView!.XPathResult.FIRST_ORDERED_NODE_TYPE,
+        //   null
+        // );
+        const result = evaluateAiXPath(xpath, docmt, "first");
+        return result.singleNodeValue;
+    }
+    catch (_error) {
+        logData_1.logger.error(`error in getAiFirstMatchedNode ${_error.message}`);
+        return null;
+    }
+};
+exports.getAiFirstMatchedNode = getAiFirstMatchedNode;
+const isAiExactUniqueXpath = (xpath, element, docmt) => {
+    try {
+        const { first, second } = (0, exports.evaluateAIXPathOnce)(xpath, docmt);
+        return !!first && !second && first === element;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isAiExactUniqueXpath = isAiExactUniqueXpath;
+const getAiAxisNodeTest = (element, platform) => {
+    const elementTagName = platform === "web" ? element.tagName.toLowerCase() : element.localName;
+    return (0, exports.isAiSvg)(element)
+        ? `*[local-name()='${elementTagName}']`
+        : elementTagName;
+};
+exports.getAiAxisNodeTest = getAiAxisNodeTest;
+const hasAnyNumber = (value) => /\d/.test(value);
+const getAiUniqueNodeAnchorXpaths = (node, docmt, isTarget, platform) => {
+    if (!node || node.nodeType !== 1)
+        return [];
+    const seen = new Set();
+    const anchors = [];
+    const MAX_ANCHORS = 3;
+    const attributes = Array.from(node.attributes || []).filter((attribute) => attribute?.value &&
+        !hasAnyNumber(attribute.value) &&
+        (0, exports.checkAiBlockedAttributes)(attribute, node, isTarget));
+    const pushAnchor = (key, value) => {
+        if (!value || seen.has(value) || anchors.length >= MAX_ANCHORS) {
+            return;
+        }
+        seen.add(value);
+        anchors.push({ key, value });
+    };
+    //  Priority attributes
+    const priorityAttrs = [
+        "id",
+        "data-testid",
+        "data-test",
+        "data-qa",
+        "name",
+        "aria-label",
+        "role"
+    ];
+    const attributeMap = new Map(attributes.map(attr => [attr.name, attr]));
+    const priorityAttrSet = new Set(priorityAttrs);
+    for (const attrName of priorityAttrs) {
+        if (anchors.length >= MAX_ANCHORS) {
+            return anchors;
+        }
+        const attr = attributeMap.get(attrName);
+        if (!attr)
+            continue;
+        const xpath = attrName === "id"
+            ? `//*[@id='${attr.value}']`
+            : (0, exports.getAiXpathString)(node, attr.name, attr.value);
+        if (xpath && (0, exports.isAiExactUniqueXpath)(xpath, node, docmt)) {
+            pushAnchor(`anchor by ${attr.name}`, xpath);
+        }
+    }
+    //  Other attributes
+    for (const attribute of attributes) {
+        if (anchors.length >= MAX_ANCHORS) {
+            return anchors;
+        }
+        if (priorityAttrSet.has(attribute.name))
+            continue;
+        const xpath = (0, exports.getAiXpathString)(node, attribute.name, attribute.value);
+        if (xpath && (0, exports.isAiExactUniqueXpath)(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.getAiFilteredTextXPath)(node);
+        if (textXpath && (0, exports.isAiExactUniqueXpath)(textXpath, node, docmt)) {
+            pushAnchor("anchor by text", textXpath);
+        }
+    }
+    if (anchors.length >= MAX_ANCHORS) {
+        return anchors;
+    }
+    //  Combination
+    if (attributes.length > 1) {
+        const combinationXpath = (0, exports.getAiAttributeCombinationXpath)(node, docmt, attributes, isTarget, platform);
+        if (combinationXpath && (0, exports.isAiExactUniqueXpath)(combinationXpath, node, docmt)) {
+            pushAnchor("anchor by combination", combinationXpath);
+        }
+    }
+    if (anchors.length >= MAX_ANCHORS) {
+        return anchors;
+    }
+    //  Tag (last fallback)
+    const tagXpath = (0, exports.getAiTagOnlyXPath)(node, platform, docmt);
+    if (tagXpath && (0, exports.isAiExactUniqueXpath)(tagXpath, node, docmt)) {
+        pushAnchor("anchor by tag", tagXpath);
+    }
+    return anchors;
+};
+exports.getAiUniqueNodeAnchorXpaths = getAiUniqueNodeAnchorXpaths;
+const getAiTextXpathFunction = (domNode) => {
+    const trimmedText = (0, exports.getAiTextContent)(domNode)?.trim();
+    const filteredText = trimmedText
+        ? (0, exports.escapeAiCharacters)(deleteAiGarbageFromInnerText(trimmedText))
+        : trimmedText;
+    if (filteredText) {
+        if (filteredText !== `'${trimmedText}'`) {
+            return `contains(.,${filteredText})`;
+        }
+        return `normalize-space(.)='${trimmedText}'`;
+    }
+};
+exports.getAiTextXpathFunction = getAiTextXpathFunction;
+const getAiXpathString = (node, attrName, attrValue) => {
+    const reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+    let xpathe = "";
+    attrValue = (0, exports.sanitizeAiAttributeValue)(attrName, attrValue);
+    if (attrValue) {
+        if (!reWhiteSpace.test(attrValue)) {
+            xpathe = (0, exports.isAiSvg)(node)
+                ? `//*[local-name()='${node.tagName}' and contains(@${attrName},${(0, exports.escapeAiCharacters)(attrValue)})]`
+                : `//${node.tagName || "*"}[contains(@${attrName},${(0, exports.escapeAiCharacters)(attrValue)})]`;
+        }
+        else if (attrName === "class") {
+            xpathe = (0, exports.isAiSvg)(node)
+                ? `//*[local-name()='${node.tagName}' and contains(@${attrName},${(0, exports.escapeAiCharacters)(attrValue)})]`
+                : `//${node.tagName || "*"}[contains(@${attrName},${(0, exports.escapeAiCharacters)(attrValue)})]`;
+        }
+        else {
+            xpathe = (0, exports.isAiSvg)(node)
+                ? `//*[local-name()='${node.tagName}' and @${attrName}=${(0, exports.escapeAiCharacters)(attrValue)}]`
+                : `//${node.tagName || "*"}[@${attrName}=${(0, exports.escapeAiCharacters)(attrValue)}]`;
+        }
+    }
+    return xpathe;
+};
+exports.getAiXpathString = getAiXpathString;
+const replaceAiActualAttributes = (str) => {
+    if (str) {
+        return str.replace(/\bdisabled\b/gi, "flndisabled");
+    }
+    return str;
+};
+exports.replaceAiActualAttributes = replaceAiActualAttributes;
+const addAttributeSplitCombineXpaths = (attributes, targetElemt, docmt, isTarget) => {
+    const attributesArray = Array.prototype.slice.call(attributes);
+    const xpaths = [];
+    try {
+        attributesArray.map((element) => {
+            if ((0, exports.checkAiBlockedAttributes)(element, targetElemt, isTarget)) {
+                const xpth = (0, exports.getAiCombinationXpath)(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.isAiNumberExist)(domNode.textContent)))) {
+        if (!exports.reWhiteSpace.test(domNode.textContent)) {
+            nodeXpath1 = (0, exports.isAiSvg)(domNode)
+                ? `*[local-name()='${domNode.tagName}' and ${(0, exports.getAiTextXpathFunction)(domNode)})]`
+                : `${domNode.tagName}[${(0, exports.getAiTextXpathFunction)(domNode)}]`;
+            if (nodeXpath1) {
+                xpaths1.push({ key: "getReferenceElementsXpath", value: nodeXpath1 });
+            }
+        }
+        else {
+            nodeXpath1 = (0, exports.isAiSvg)(domNode)
+                ? `*[local-name()='${domNode.tagName}' and .=${(0, exports.escapeAiCharacters)((0, exports.getAiTextContent)(domNode))}]`
+                : `${domNode.tagName}[.=${(0, exports.escapeAiCharacters)((0, exports.getAiTextContent)(domNode))}]`;
+            if (nodeXpath1) {
+                xpaths1.push({ key: "getReferenceElementsXpath", value: nodeXpath1 });
+            }
+        }
+    }
+    if (domNode.attributes) {
+        for (const attrName of Array.from(domNode.attributes)) {
+            if ((0, exports.checkAiBlockedAttributes)(attrName, domNode, isTarget)) {
+                let attrValue = attrName.nodeValue;
+                if (attrValue) {
+                    attrValue = (0, exports.sanitizeAiAttributeValue)(attrName.name, attrValue);
+                    const elementName = attrName.name;
+                    if (elementName === "class") {
+                        nodeXpath1 = (0, exports.isAiSvg)(domNode)
+                            ? `*[local-name()='${domNode.tagName}' and contains(@${elementName},${(0, exports.escapeAiCharacters)(attrValue)})]`
+                            : `${domNode.tagName}[contains(@${elementName},${(0, exports.escapeAiCharacters)(attrValue)})]`;
+                    }
+                    else {
+                        nodeXpath1 = (0, exports.isAiSvg)(domNode)
+                            ? `*[local-name()='${domNode.tagName}' and @${elementName}=${(0, exports.escapeAiCharacters)(attrValue)}]`
+                            : `${domNode.tagName}[@${elementName}=${(0, exports.escapeAiCharacters)(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.getAiAttributeCombinationXpath)(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.isAiSvg)(domNode);
+        if (domNode.textContent && isTarget && (0, exports.isAiNumberExist)(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.aiReplaceWhiteSpaces)(contentRes[i].trim())?.length > 1) {
+                        if (!exports.reWhiteSpace.test(contentRes[i])) {
+                            combinePattern.push(`contains(.,${(0, exports.escapeAiCharacters)((0, exports.aiReplaceWhiteSpaces)(contentRes[i])).trim()})`);
+                        }
+                        else {
+                            combinePattern.push(`contains(.,${(0, exports.escapeAiCharacters)(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 isAiUniqueInDOM(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;
+    }
+}
+exports.xpathUtils = {
+    getReferenceElementsXpath: exports.getReferenceElementsXpath,
+    getAiAbsoluteXPath: exports.getAiAbsoluteXPath,
+    getAIRelativeXPath: exports.getAIRelativeXPath,
+    getAiCombinationXpath: exports.getAiCombinationXpath,
+    getAiAttributeCombinationXpath: exports.getAiAttributeCombinationXpath,
+    isAiSvg: exports.isAiSvg,
+    findAiXpathWithIndex: exports.findAiXpathWithIndex,
+    isAiNumberExist: exports.isAiNumberExist,
+    getAiTextContent: exports.getAiTextContent,
+    getAiCountOfXPath: exports.getAiCountOfXPath,
+    normalizeXPath: exports.normalizeXPath,
+    getAiShadowRoot: exports.getAiShadowRoot,
+    escapeAiCharacters: exports.escapeAiCharacters,
+    removeAiParenthesis: exports.removeAiParenthesis,
+    checkAiBlockedAttributes: exports.checkAiBlockedAttributes,
+    getAiRelationship: exports.getAiRelationship,
+    findMatchingParenthesis: exports.findMatchingParenthesis,
+    deleteAiGarbageFromInnerText,
+    replaceAiTempAttributes: exports.replaceAiTempAttributes,
+    // createObserver,
+    // startObserver,
+    // stopObserver,
+    modifiedElementAttributes: exports.modifiedElementAttributes,
+    cspEnabled: exports.cspEnabled,
+    getAiNormalizedPropertyXPath: exports.getAiNormalizedPropertyXPath,
+    getAiStartsWithPropertyXPath: exports.getAiStartsWithPropertyXPath,
+    getAiContainsPropertyXPath: exports.getAiContainsPropertyXPath,
+    getOrAttributesAiXPath: exports.getOrAttributesAiXPath,
+    getAiTagOnlyXPath: exports.getAiTagOnlyXPath,
+    getAiFirstMatchedNode: exports.getAiFirstMatchedNode,
+    isAiExactUniqueXpath: exports.isAiExactUniqueXpath,
+    getAiAxisNodeTest: exports.getAiAxisNodeTest,
+    getAiUniqueNodeAnchorXpaths: exports.getAiUniqueNodeAnchorXpaths,
+    escapeAttrValue,
+    isAiUniqueInDOM,
+    sanitizeAiAttributeValue: exports.sanitizeAiAttributeValue
+};