ff-automationv2 2.2.28 → 2.2.30

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

@@ -0,0 +1,710 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiParseDOM = exports.getAiTextXPath = exports.getAiUniqueClassName = exports.attributesAiBasedXPath = void 0;
+const logData_js_1 = require("../../../utils/logger/logData.js");
+const xpathHelpers_js_1 = require("./xpathHelpers.js");
+const androidSelector_js_1 = require("./androidSelector.js");
+const iosSelector_js_1 = require("./iosSelector.js");
+let xpathData = [];
+const xpathValues = new Set();
+const MAX_XPATH_RESULTS = 5;
+const referenceElementMode = false;
+const xpathCache = new Map();
+const cache = new Map();
+const parentRelativeCache = new WeakMap();
+const parentXpathCache = new Map();
+const filteredTextCache = new WeakMap();
+const textContentCache = new WeakMap();
+const appendXPath = (target, xpath) => {
+    if (!xpath.value)
+        return false;
+    if (xpathValues.has(xpath.value))
+        return true;
+    if (target.length >= MAX_XPATH_RESULTS)
+        return false;
+    target.push(xpath);
+    xpathValues.add(xpath.value);
+    return target.length < MAX_XPATH_RESULTS;
+};
+const hasReachedRelativeXpathLimit = () => {
+    return xpathData.length >= MAX_XPATH_RESULTS;
+};
+const getCachedXPathCount = (xpath, element, doc) => {
+    try {
+        const cached = xpathCache.get(xpath);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const count = (0, xpathHelpers_js_1.getAiCountOfXPath)(xpath, element, doc);
+        xpathCache.set(xpath, count);
+        return count;
+    }
+    catch {
+        return 0;
+    }
+};
+const getCachedTextContent = (element) => {
+    const cached = textContentCache.get(element);
+    if (cached !== undefined)
+        return cached;
+    const value = (0, xpathHelpers_js_1.getAiTextContent)(element);
+    textContentCache.set(element, value);
+    return value;
+};
+const getCachedFilteredText = (element) => {
+    const cached = filteredTextCache.get(element);
+    if (cached !== undefined)
+        return cached;
+    const value = (0, xpathHelpers_js_1.getAiFilteredText)(element);
+    filteredTextCache.set(element, value);
+    return value;
+};
+const checkAiRelativeXpathRelation = (nodeXpath1, nodeXpath2, targetElemt, docmt, relationType) => {
+    if (hasReachedRelativeXpathLimit()) {
+        return;
+    }
+    if (nodeXpath1 && !referenceElementMode) {
+        let xpaths;
+        if (relationType === "parent") {
+            xpaths = [
+                `${nodeXpath1}/descendant-or-self::${nodeXpath2}`,
+                `${nodeXpath1}/following::${nodeXpath2}`
+            ];
+        }
+        else {
+            xpaths = [
+                `${nodeXpath1}/ancestor-or-self::${nodeXpath2}`,
+                `${nodeXpath1}/preceding::${nodeXpath2}`
+            ];
+        }
+        // Iterate through XPath patterns
+        for (const xpath of xpaths) {
+            // Check if result is already cached to avoid recomputation
+            if (!xpathCache?.get(xpath)) {
+                // Compute and store result in cache
+                xpathCache.set(xpath, getCachedXPathCount(xpath, targetElemt, docmt));
+            }
+            const count = xpathCache?.get(xpath);
+            // Short-circuit: Return the first valid XPath result found
+            if (count === 1) {
+                return xpath;
+            }
+        }
+    }
+    return null;
+};
+const getAiUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, _platform) => {
+    try {
+        if (parentXpathCache.has(domNode)) {
+            return parentXpathCache.get(domNode);
+        }
+        // Direct XPath construction without loops
+        const xpathParts = [];
+        let currentNode = domNode;
+        while (currentNode && currentNode.nodeType === 1) {
+            if (hasReachedRelativeXpathLimit()) {
+                return null;
+            }
+            const PRIORITY = [
+                "id",
+                "name",
+                "data-testid",
+                "data-test",
+                "aria-label",
+                "placeholder",
+                "class"
+            ];
+            const attrs = Array
+                .from(currentNode.attributes)
+                .sort((a, b) => {
+                const ai = PRIORITY.indexOf(a.name);
+                const bi = PRIORITY.indexOf(b.name);
+                return (ai == -1 ? 999 : ai) - (bi == -1 ? 999 : bi);
+            })
+                .slice(0, 3);
+            for (const attrName of attrs) {
+                if ((0, xpathHelpers_js_1.checkAiBlockedAttributes)(attrName, currentNode, isTarget)) {
+                    const attrValue = (0, xpathHelpers_js_1.sanitizeAiAttributeValue)(attrName.name, attrName.nodeValue);
+                    const elementName = attrName.name;
+                    const xpathe = (0, xpathHelpers_js_1.getAiXpathString)(currentNode, elementName, attrValue);
+                    let othersWithAttr;
+                    // If the XPath does not parse, move to the next unique attribute
+                    try {
+                        othersWithAttr = checkAiRelativeXpathRelation(xpathe, nodeXpath, node, docmt, "parent");
+                    }
+                    catch (ign) {
+                        logData_js_1.logger.error("error in getAiUniqueParentXpath", ign);
+                        continue;
+                    }
+                    // If the attribute isn't actually unique, get it's index too
+                    if (othersWithAttr) {
+                        return othersWithAttr;
+                    }
+                }
+            }
+            const text = getCachedFilteredText(currentNode);
+            if (text) {
+                if (!isTarget ||
+                    (isTarget && !(0, xpathHelpers_js_1.isAiNumberExist)(text))) {
+                    let xpathe;
+                    if (!xpathHelpers_js_1.reWhiteSpace.test(currentNode.textContent)) {
+                        xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
+                            ? `//*[local-name()='${currentNode.tagName}' and normalize-space(.)=${(0, xpathHelpers_js_1.escapeAiCharacters)(getCachedFilteredText(currentNode))}]`
+                            : `//${currentNode.tagName || "*"}[normalize-space(.)=${(0, xpathHelpers_js_1.escapeAiCharacters)(getCachedFilteredText(currentNode))}]`;
+                    }
+                    else {
+                        xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
+                            ? `//*[local-name()='${currentNode.tagName}' and .=${(0, xpathHelpers_js_1.escapeAiCharacters)(getCachedFilteredText(currentNode))}]`
+                            : `//${currentNode.tagName || "*"}[.=${(0, xpathHelpers_js_1.escapeAiCharacters)(getCachedFilteredText(currentNode))}]`;
+                    }
+                    const othersWithAttr = checkAiRelativeXpathRelation(xpathe, nodeXpath, node, docmt, "parent");
+                    if (othersWithAttr) {
+                        return othersWithAttr;
+                    }
+                }
+                else {
+                    const combinePattern = [];
+                    const contentRes = [
+                        ...new Set(getCachedFilteredText(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, xpathHelpers_js_1.aiReplaceWhiteSpaces)(contentRes[i].trim())) {
+                                if (!reWhiteSpace.test(contentRes[i])) {
+                                    combinePattern.push(`contains(.,${(0, xpathHelpers_js_1.escapeAiCharacters)((0, xpathHelpers_js_1.aiReplaceWhiteSpaces)(contentRes[i])).trim()})`);
+                                }
+                                else {
+                                    combinePattern.push(`contains(.,${(0, xpathHelpers_js_1.escapeAiCharacters)(contentRes[i].trim()).trim()})`);
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        const xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
+                            ? `//*[local-name()='${currentNode.tagName}' and ${combinePattern.join(" and ")}]`
+                            : `//${currentNode.tagName || "*"}[${combinePattern.join(" and ")}]`;
+                        const othersWithAttr = checkAiRelativeXpathRelation(xpathe, nodeXpath, node, docmt, "parent");
+                        if (othersWithAttr) {
+                            return othersWithAttr;
+                        }
+                    }
+                }
+            }
+            // Construct the XPath based on the tag name
+            const xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
+                ? `/*[local-name()='${currentNode.tagName}']`
+                : `/${currentNode.tagName}`;
+            xpathParts.unshift(xpathe);
+            // Move to the parent node for the next iteration
+            currentNode = currentNode.parentElement;
+        }
+        // Final constructed XPath
+        const finalXPath = xpathParts.join("") + nodeXpath;
+        const count = getCachedXPathCount(finalXPath, domNode, docmt);
+        if (count === 1) {
+            parentXpathCache.set(domNode, finalXPath); // Cache final result
+            return finalXPath;
+        }
+    }
+    catch (error) {
+        console.error(error);
+        return null;
+    }
+};
+const getAiParentRelativeXpath = (domNode, docmt, node, isTarget, _platform) => {
+    if (parentRelativeCache.has(domNode)) {
+        return parentRelativeCache.get(domNode); // Return cached result if available
+    }
+    const xpathParts = []; // Initialize an array to hold parts of the XPath
+    let currentNode = domNode; // Start with the provided DOM node
+    try {
+        while (currentNode && currentNode.nodeType === 1) {
+            if (hasReachedRelativeXpathLimit()) {
+                return null;
+            }
+            // BASE CASE #1: If this isn't an element, we're above the root, return empty string
+            if (!currentNode.tagName) {
+                return "";
+            }
+            // BASE CASE #2: Check for unique attributes
+            let uniqueAttrFound = false;
+            const PRIORITY = [
+                "id",
+                "name",
+                "data-testid",
+                "data-test",
+                "aria-label",
+                "placeholder",
+                "class"
+            ];
+            const attrs = Array
+                .from(currentNode.attributes)
+                .sort((a, b) => {
+                const ai = PRIORITY.indexOf(a.name);
+                const bi = PRIORITY.indexOf(b.name);
+                return (ai == -1 ? 999 : ai) - (bi == -1 ? 999 : bi);
+            })
+                .slice(0, 3);
+            for (const attr of attrs) {
+                if ((0, xpathHelpers_js_1.checkAiBlockedAttributes)(attr, currentNode, isTarget)) {
+                    const attrValue = (0, xpathHelpers_js_1.sanitizeAiAttributeValue)(attr.name, attr.nodeValue);
+                    const elementName = attr.name;
+                    const xpathe = (0, xpathHelpers_js_1.getAiXpathString)(currentNode, elementName, attrValue);
+                    let othersWithAttr;
+                    // If the XPath does not parse, move to the next unique attribute
+                    try {
+                        othersWithAttr = getCachedXPathCount(xpathe, currentNode, docmt);
+                    }
+                    catch (ign) {
+                        logData_js_1.logger.error("error in getAiParentRelativeXpath", ign);
+                        continue;
+                    }
+                    // If the attribute is unique, return its XPath
+                    if (othersWithAttr === 1) {
+                        xpathParts.unshift(xpathe);
+                        uniqueAttrFound = true; // Mark that we found at least one unique attribute
+                        break;
+                    }
+                }
+            }
+            // If no unique attributes, check for text content
+            if (!uniqueAttrFound && !currentNode.textContent && !node.textContent) {
+                const textXPath = (0, xpathHelpers_js_1.getAiFilteredTextXPath)(currentNode);
+                if (textXPath) {
+                    const othersWithAttr = getCachedXPathCount(textXPath, currentNode, docmt);
+                    if (othersWithAttr === 1) {
+                        uniqueAttrFound = true; // Mark that we found at least one unique attribute
+                        xpathParts.unshift(textXPath);
+                        break;
+                    }
+                }
+            }
+            if (!uniqueAttrFound) {
+                // Construct the XPath based on the tag name
+                const xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
+                    ? `/*[local-name()='${currentNode.tagName}']`
+                    : `/${currentNode.tagName}`;
+                // Prepend the current XPath part to the array
+                xpathParts.unshift(xpathe);
+            }
+            else {
+                break;
+            }
+            // Move to the parent node for the next iteration
+            currentNode = currentNode.parentElement;
+        }
+        // Combine all parts into the final XPath
+        const finalXpath = xpathParts.join("");
+        cache.set(domNode, finalXpath); // Store result in cache
+        return finalXpath;
+    }
+    catch (error) {
+        logData_js_1.logger.error(error);
+        return null;
+    }
+};
+const getAiChildRelativeXpath = (domNode, docmt, node) => {
+    const xpathParts = []; // Initialize an array to hold parts of the XPath.
+    let currentNode;
+    const st = [];
+    if (domNode.firstElementChild != null &&
+        domNode.firstElementChild.classList.contains("flntooltip")) {
+        st.unshift(domNode.firstElementChild);
+    }
+    else if (domNode.nextElementSibling != null)
+        st.unshift(domNode.nextElementSibling);
+    for (let m = domNode.parentElement; m != null && m.nodeType === 1; m = m.parentElement) {
+        if (m.nextElementSibling)
+            st.unshift(m.nextElementSibling);
+    }
+    try {
+        let processedNodes = 0;
+        do {
+            let uniqueAttrFound = false;
+            for (currentNode = st.pop(); currentNode !== null;) {
+                if (++processedNodes > 30) {
+                    return null;
+                }
+                if (hasReachedRelativeXpathLimit()) {
+                    return null;
+                }
+                const PRIORITY = [
+                    "id",
+                    "name",
+                    "data-testid",
+                    "data-test",
+                    "aria-label",
+                    "placeholder",
+                    "class"
+                ];
+                const attrs = Array
+                    .from(currentNode.attributes)
+                    .sort((a, b) => {
+                    const ai = PRIORITY.indexOf(a.name);
+                    const bi = PRIORITY.indexOf(b.name);
+                    return (ai == -1 ? 999 : ai) - (bi == -1 ? 999 : bi);
+                })
+                    .slice(0, 3);
+                for (const attr of attrs) {
+                    if ((0, xpathHelpers_js_1.checkAiBlockedAttributes)(attr, currentNode, true)) {
+                        const attrValue = (0, xpathHelpers_js_1.sanitizeAiAttributeValue)(attr.name, attr.nodeValue);
+                        const elementName = attr.name;
+                        const xpathe = (0, xpathHelpers_js_1.getAiXpathString)(currentNode, elementName, attrValue);
+                        let othersWithAttr;
+                        // If the XPath does not parse, move to the next unique attribute
+                        try {
+                            othersWithAttr = getCachedXPathCount(xpathe, currentNode, docmt);
+                        }
+                        catch (ign) {
+                            logData_js_1.logger.error("error in getAiChildRelativeXpath", ign);
+                            continue;
+                        }
+                        // If the attribute is unique, return its XPath
+                        if (othersWithAttr === 1) {
+                            uniqueAttrFound = true; // Mark that we found at least one unique attribute
+                            xpathParts.push(xpathe);
+                            break;
+                        }
+                    }
+                }
+                // If no unique attributes, check for text content
+                if (!uniqueAttrFound && currentNode.textContent && !node.textContent) {
+                    const textXPath = (0, xpathHelpers_js_1.getAiFilteredTextXPath)(currentNode);
+                    if (textXPath) {
+                        const othersWithAttr = getCachedXPathCount(textXPath, currentNode, docmt);
+                        if (othersWithAttr === 1) {
+                            uniqueAttrFound = true; // Mark that we found at least one unique attribute
+                            xpathParts.push(textXPath);
+                            break;
+                        }
+                    }
+                }
+                if (!uniqueAttrFound) {
+                    // Construct the XPath based on the tag name
+                    const xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
+                        ? `/*[local-name()='${currentNode.tagName}']`
+                        : `/${currentNode.tagName}`;
+                    // Prepend the current XPath part to the array
+                    xpathParts.push(xpathe);
+                    if (currentNode.firstElementChild != null) {
+                        st.push(currentNode.nextElementSibling);
+                        currentNode = currentNode.firstElementChild;
+                    }
+                    else {
+                        currentNode = currentNode.nextElementSibling;
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+        } while (st.length > 0);
+        // Combine all parts into the final XPath
+        const finalXpath = xpathParts.join("");
+        cache.set(domNode, finalXpath); // Store result in cache
+        return finalXpath;
+    }
+    catch (error) {
+        logData_js_1.logger.error("error in getAiChildRelativeXpath", error);
+        return null;
+    }
+};
+const getAiSiblingRelativeXPath = (domNode, docmt, isTarget, nodeXpath, platform) => {
+    try {
+        const markedSpan = domNode.ownerDocument?.querySelector(".flntooltip");
+        for (let m = domNode.nextElementSibling; m !== null && m !== markedSpan; m = m.nextElementSibling) {
+            if (hasReachedRelativeXpathLimit()) {
+                return xpathData;
+            }
+            processAiSibling(m, domNode, docmt, nodeXpath, "preceding-sibling", isTarget, platform);
+        }
+        for (let n = domNode.previousElementSibling; n !== null && n !== markedSpan; n = n.previousElementSibling) {
+            if (hasReachedRelativeXpathLimit()) {
+                return;
+            }
+            processAiSibling(n, domNode, docmt, nodeXpath, "following-sibling", isTarget, platform);
+        }
+    }
+    catch {
+        return null;
+    }
+};
+const processAiSibling = (sibling, domNode, docmt, nodeXpath, axis, isTarget, _platform) => {
+    try {
+        if (hasReachedRelativeXpathLimit()) {
+            return;
+        }
+        if (sibling.hasAttributes()) {
+            const PRIORITY = [
+                "id",
+                "name",
+                "data-testid",
+                "data-test",
+                "aria-label",
+                "placeholder",
+                "class"
+            ];
+            const attrs = Array
+                .from(sibling.attributes)
+                .sort((a, b) => {
+                const ai = PRIORITY.indexOf(a.name);
+                const bi = PRIORITY.indexOf(b.name);
+                return (ai == -1 ? 999 : ai) - (bi == -1 ? 999 : bi);
+            })
+                .slice(0, 3);
+            for (const attr of attrs) {
+                if (hasReachedRelativeXpathLimit()) {
+                    return;
+                }
+                let xpathe = (0, xpathHelpers_js_1.intermediateAiXpathStep)(sibling, {
+                    name: attr.name,
+                    value: attr.value
+                }, isTarget);
+                if (xpathe) {
+                    xpathe += `/${axis}::${nodeXpath}`;
+                    const count = getCachedXPathCount(xpathe, sibling, docmt);
+                    if (count === 1) {
+                        if (!appendXPath(xpathData, {
+                            key: `xpath by ${axis}`,
+                            value: xpathe
+                        })) {
+                            return;
+                        }
+                        if (hasReachedRelativeXpathLimit()) {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        if (!isTarget) {
+            const xpathe = (0, xpathHelpers_js_1.intermediateAiXpathStep)(sibling, {
+                name: "text",
+                value: getCachedTextContent(sibling)
+            }, isTarget);
+            if (xpathe) {
+                const count = getCachedXPathCount(xpathe, sibling, docmt);
+                if (count === 1) {
+                    if (!appendXPath(xpathData, {
+                        key: `xpath by ${axis}`,
+                        value: xpathe
+                    })) {
+                        return;
+                    }
+                    return;
+                }
+            }
+        }
+    }
+    catch (error) {
+        logData_js_1.logger.error(`${axis} xpath-error`, error.message);
+    }
+};
+function getAiXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget) {
+    const { tagName } = targetElemt;
+    const textContent = getCachedTextContent(targetElemt);
+    if (!textContent) {
+        return;
+    }
+    for (const attrName of attributes) {
+        if ((0, xpathHelpers_js_1.checkAiBlockedAttributes)(attrName, targetElemt, isTarget)) {
+            const attrValue = (0, xpathHelpers_js_1.sanitizeAiAttributeValue)(attrName.name, attrName.nodeValue);
+            const elementName = attrName.name;
+            const xpath = `//${tagName}[@${elementName}='${attrValue}' and text()='${textContent}']`;
+            if (xpath) {
+                const count = getCachedXPathCount(xpath, targetElemt, docmt);
+                if (count == 1) {
+                    return xpath;
+                }
+            }
+        }
+    }
+}
+const attributesAiBasedXPath = (attr, targetElemt, docmt, isTarget, platform) => {
+    const attrName = attr.name;
+    const xpath = (0, xpathHelpers_js_1.getAiPropertyXPath)(targetElemt, docmt, `@${attrName}`, attr.value, isTarget, platform);
+    return xpath;
+};
+exports.attributesAiBasedXPath = attributesAiBasedXPath;
+const getAiUniqueClassName = (element, docmt, isTarget, platform) => {
+    let value = element.className;
+    if (typeof value !== "string") {
+        value = "";
+    }
+    value = value?.replace("flndisabled", "disabled");
+    value = (0, xpathHelpers_js_1.sanitizeAiAttributeValue)("class", value);
+    value = value?.trim();
+    if (value) {
+        return (0, xpathHelpers_js_1.getAiPropertyXPath)(element, docmt, `@class`, value, isTarget, platform);
+    }
+};
+exports.getAiUniqueClassName = getAiUniqueClassName;
+const getAiTextXPath = (element, docmt, isTarget, platform) => {
+    if ((element.textContent ?? "").trim() != "") {
+        const text = getCachedTextContent(element);
+        if (text) {
+            return (0, xpathHelpers_js_1.getAiPropertyXPath)(element, docmt, ".", text, isTarget, platform);
+        }
+    }
+};
+exports.getAiTextXPath = getAiTextXPath;
+const addAiAllXPathAttributes = (attributes, targetElemt, docmt, isTarget, platform) => {
+    const attributesArray = attributes;
+    try {
+        attributesArray.map((attr) => {
+            if (!(attr.name === "className" || attr.name === "class")) {
+                if ((0, xpathHelpers_js_1.checkAiBlockedAttributes)(attr, targetElemt, isTarget)) {
+                    const xpth = (0, exports.attributesAiBasedXPath)(attr, targetElemt, docmt, isTarget, platform);
+                    if (xpth) {
+                        if (!appendXPath(xpathData, {
+                            key: `xpath by ${attr.name}`,
+                            value: xpth
+                        })) {
+                            return;
+                        }
+                    }
+                    const containsXpath = (0, xpathHelpers_js_1.getAiContainsPropertyXPath)(targetElemt, `@${attr.name}`, attr.value, platform);
+                    if (containsXpath &&
+                        getCachedXPathCount(containsXpath, targetElemt, docmt) === 1) {
+                        if (!appendXPath(xpathData, {
+                            key: `xpath by contains ${attr.name}`,
+                            value: containsXpath
+                        })) {
+                            return;
+                        }
+                    }
+                    const startsWithXpath = (0, xpathHelpers_js_1.getAiStartsWithPropertyXPath)(targetElemt, `@${attr.name}`, attr.value, platform);
+                    if (startsWithXpath &&
+                        getCachedXPathCount(startsWithXpath, targetElemt, docmt) === 1) {
+                        if (!appendXPath(xpathData, {
+                            key: `xpath by startsWith ${attr.name}`,
+                            value: startsWithXpath
+                        })) {
+                            return;
+                        }
+                    }
+                }
+            }
+        });
+        const txtXpath = (0, exports.getAiTextXPath)(targetElemt, docmt, isTarget, platform);
+        if (txtXpath) {
+            if (!appendXPath(xpathData, {
+                key: "xpath by text",
+                value: txtXpath
+            })) {
+                return;
+            }
+        }
+        const classNameAttr = attributesArray.find((element) => element.name === "className");
+        if (classNameAttr && (0, xpathHelpers_js_1.checkAiBlockedAttributes)(classNameAttr, targetElemt, isTarget)) {
+            const xpath = (0, exports.getAiUniqueClassName)(targetElemt, docmt, isTarget, platform);
+            if (xpath) {
+                if (!appendXPath(xpathData, {
+                    key: "xpath by class",
+                    value: xpath
+                })) {
+                    return;
+                }
+            }
+        }
+        if (!xpathData.length && attributesArray.length > 1) {
+            const combinationXpath = (0, xpathHelpers_js_1.getAiAttributeCombinationXpath)(targetElemt, docmt, attributesArray, isTarget, platform);
+            if (combinationXpath) {
+                if (!appendXPath(xpathData, {
+                    key: "xpath by combination",
+                    value: combinationXpath
+                })) {
+                    return;
+                }
+            }
+        }
+        if (!xpathData.length) {
+            const textAttribute = getAiXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget);
+            if (textAttribute) {
+                if (!appendXPath(xpathData, {
+                    key: "xpath by textAttribute",
+                    value: textAttribute
+                })) {
+                    return;
+                }
+            }
+        }
+    }
+    catch (error) {
+        logData_js_1.logger.error("Error in addAiAllXPathAttributes:", error);
+    }
+};
+const aiParseDOM = (element, doc, isTarget, includedAttributes = [], platform) => {
+    xpathData = [];
+    xpathValues.clear();
+    xpathCache.clear();
+    const targetElemt = element;
+    const rootNode = targetElemt?.getRootNode?.();
+    const DOCUMENT_FRAGMENT_NODE = 11;
+    const isShadowScoped = rootNode?.nodeType === DOCUMENT_FRAGMENT_NODE;
+    const docmt = (isShadowScoped ? rootNode : targetElemt?.ownerDocument || doc);
+    const tag = targetElemt.tagName;
+    const { attributes } = targetElemt;
+    const attributesToUse = includedAttributes.length > 0 ? includedAttributes : Array.from(attributes);
+    addAiAllXPathAttributes(attributesToUse, targetElemt, docmt, isTarget, platform);
+    if (xpathData.length >= MAX_XPATH_RESULTS) {
+        return xpathData;
+    }
+    if (platform === "android") {
+        xpathData.push(...(0, androidSelector_js_1.generateAiAndroidLocators)(targetElemt, docmt, isTarget));
+    }
+    else if (platform === "ios") {
+        xpathData.push(...(0, iosSelector_js_1.generateAiIOSLocators)(targetElemt, docmt, isTarget));
+    }
+    if (xpathData.length >= MAX_XPATH_RESULTS) {
+        return xpathData;
+    }
+    if (platform === "android" && !xpathData.length) {
+        const relativeXpath = (0, xpathHelpers_js_1.getAIRelativeXPath)(targetElemt, docmt, isTarget, attributesToUse, platform);
+        if (relativeXpath && getCachedXPathCount(relativeXpath, targetElemt, docmt) === 1) {
+            appendXPath(xpathData, {
+                key: "Relative xpath",
+                value: relativeXpath
+            });
+        }
+    }
+    if (!referenceElementMode && xpathData.length < MAX_XPATH_RESULTS) {
+        if (xpathData.length) {
+            const len = xpathData.length;
+            for (let i = 0; i < len; i++) {
+                let xpth = xpathData[i].value;
+                if (xpth.startsWith(`//${tag}`)) {
+                    xpth = "//*" + xpth.substring(2 + tag.length);
+                }
+                if (getCachedXPathCount(xpth, element, docmt) === 1) {
+                    if (!appendXPath(xpathData, {
+                        key: `${xpathData[i].key} regex`,
+                        value: xpth
+                    })) {
+                        return xpathData;
+                    }
+                    if (xpathData.length >= MAX_XPATH_RESULTS) {
+                        return xpathData;
+                    }
+                }
+            }
+        }
+    }
+    return xpathData;
+};
+exports.aiParseDOM = aiParseDOM;
+const xpath = {
+    aiParseDOM: exports.aiParseDOM,
+    getAiTextXPath: exports.getAiTextXPath,
+    getAiUniqueClassName: exports.getAiUniqueClassName,
+    attributesAiBasedXPath: exports.attributesAiBasedXPath,
+    addAiAllXPathAttributes,
+    getAiXPathUsingAttributeAndText,
+    getAiSiblingRelativeXPath,
+    getAiChildRelativeXpath,
+    getAiParentRelativeXpath,
+    getAiUniqueParentXpath,
+    checkAiRelativeXpathRelation
+};
+exports.default = xpath;