ff-automationv2 2.2.35 → 2.2.36-beta.0

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

@@ -1,710 +0,0 @@
-"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;