ff-automationv2 2.2.29 → 2.2.31

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

@@ -1,439 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDOM = exports.getTextXPath = exports.getUniqueClassName = exports.attributesBasedXPath = exports.generateIndexedXpaths = void 0;
+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 xpathDataWithIndex = [];
+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 STRATEGY_MAP = {
-    andConditions: "and",
-    orConditions: "or",
-    contains: "contains",
-    startsWith: "startsWith",
-    normalizeSpace: "normalizeSpace",
-    axes: "axes",
-    index: "index",
-    hardCodedText: "text",
-    tillTag: "tag"
-};
-const getStrategyName = (strategy) => {
-    return STRATEGY_MAP[strategy] || strategy;
-};
-const withStrategyKey = (strategy, entries) => {
-    return entries.map((entry) => ({
-        ...entry,
-        key: entry?.key?.includes(strategy)
-            ? entry.key
-            : `${strategy} ${entry.key}`.trim()
-    }));
-};
-const getUniqueXpathEntries = (entries) => {
-    const seen = new Set();
-    return entries.filter((entry) => {
-        if (!entry?.value || seen.has(entry.value)) {
-            return false;
-        }
-        seen.add(entry.value);
+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 getNormalizedText = (element) => {
-    return element?.textContent?.replace(/\s+/g, " ")?.trim() || "";
+const hasReachedRelativeXpathLimit = () => {
+    return xpathData.length >= MAX_XPATH_RESULTS;
 };
-const buildTextStrategyXpaths = (element, docmt, strategy, platform) => {
-    const text = getNormalizedText(element);
-    if (!text) {
-        return [];
-    }
-    if (strategy === "text") {
-        const textXpath = (0, xpathHelpers_js_1.getFilteredTextXPath)(element) ||
-            (0, exports.getTextXPath)(element, docmt, false, false, platform);
-        return textXpath ? [{ key: "xpath by text", value: textXpath }] : [];
-    }
-    return [];
-};
-const buildPropertyStrategyXpaths = (element, isTarget, strategy, platform) => {
-    const xpaths = [];
-    const attributes = Array.from(element.attributes || []).filter((attribute) => attribute?.value && (0, xpathHelpers_js_1.checkBlockedAttributes)(attribute, element, isTarget));
-    const text = getNormalizedText(element);
-    const getStrategyXPath = strategy === "contains"
-        ? xpathHelpers_js_1.getContainsPropertyXPath
-        : strategy === "startsWith"
-            ? xpathHelpers_js_1.getStartsWithPropertyXPath
-            : strategy === "normalizeSpace"
-                ? xpathHelpers_js_1.getNormalizedPropertyXPath
-                : null;
-    if (!getStrategyXPath) {
-        return xpaths;
-    }
-    attributes.forEach((attribute) => {
-        const xpath = getStrategyXPath(element, `@${attribute.name}`, attribute.value, platform);
-        if (xpath) {
-            xpaths.push({
-                key: `xpath by ${strategy} ${attribute.name}`,
-                value: xpath
-            });
-        }
-    });
-    if (text) {
-        const xpath = getStrategyXPath(element, ".", text, platform);
-        if (xpath) {
-            xpaths.push({
-                key: `xpath by ${strategy} text`,
-                value: xpath
-            });
+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;
     }
-    return xpaths;
-};
-const buildConditionStrategyXpaths = (element, docmt, isTarget, strategy, platform) => {
-    const attributes = Array.from(element.attributes || []).filter((attribute) => attribute?.value && (0, xpathHelpers_js_1.checkBlockedAttributes)(attribute, element, isTarget));
-    if (strategy === "and") {
-        const combinationXpath = (0, xpathHelpers_js_1.getAttributeCombinationXpath)(element, docmt, attributes, isTarget, platform);
-        return combinationXpath
-            ? [{ key: "xpath by combination", value: combinationXpath }]
-            : [];
-    }
-    if (strategy === "or" && attributes.length >= 1) {
-        const xpath = (0, xpathHelpers_js_1.getOrAttributesXPath)(element, attributes, platform);
-        return xpath ? [{ key: "xpath by or", value: xpath }] : [];
+    catch {
+        return 0;
     }
-    return [];
 };
-const collectSubtreeElements = (root) => {
-    const view = root?.ownerDocument?.defaultView;
-    if (!root || !view || !(root instanceof view.Element))
-        return [];
-    const nodes = [];
-    const queue = Array.from(root.children || []);
-    while (queue.length) {
-        const currentNode = queue.shift();
-        if (currentNode.classList?.contains("flntooltip")) {
-            continue;
-        }
-        nodes.push(currentNode);
-        queue.push(...Array.from(currentNode.children || []));
-    }
-    return nodes;
+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 getSiblingNodes = (element, direction) => {
-    const nodes = [];
-    let currentNode = direction === "previous"
-        ? element.previousElementSibling
-        : element.nextElementSibling;
-    while (currentNode) {
-        if (!currentNode.classList?.contains("flntooltip")) {
-            nodes.push(currentNode);
-        }
-        currentNode =
-            direction === "previous"
-                ? currentNode.previousElementSibling
-                : currentNode.nextElementSibling;
-    }
-    return nodes;
-};
-const getDirectionalAxisSeedNodes = (element, direction) => {
-    const nodes = [];
-    for (let currentNode = element; currentNode?.parentElement; currentNode = currentNode.parentElement) {
-        let sibling = direction === "previous"
-            ? currentNode.previousElementSibling
-            : currentNode.nextElementSibling;
-        while (sibling) {
-            if (!sibling.classList?.contains("flntooltip")) {
-                nodes.push(sibling);
-                nodes.push({
-                    node: sibling,
-                    expand: () => collectSubtreeElements(sibling)
-                });
-            }
-            sibling =
-                direction === "previous"
-                    ? sibling.previousElementSibling
-                    : sibling.nextElementSibling;
-        }
-    }
-    return nodes;
+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 isLowQualityNode = (node) => {
-    const view = node?.ownerDocument?.defaultView;
-    if (!view || !(node instanceof view.Element))
-        return true;
-    const text = node.textContent?.trim();
-    return (!node.id &&
-        !node.className &&
-        node.attributes.length === 0 &&
-        (!text || text.length > 60) &&
-        node.children.length > 2);
-};
-const buildAxisXpathsForNodes = (nodes, axis, targetElement, docmt, isTarget, key, isIndex, platform) => {
-    const targetNodeTest = (0, xpathHelpers_js_1.getAxisNodeTest)(targetElement, platform);
-    const MAX_INDEX_TRY = 3;
-    const MAX_CANDIDATES = 5;
-    const candidates = [];
-    let processed = 0;
-    const MAX_PROCESS = axis.includes("descendant") ? 10 : 20;
-    for (const nodeItem of nodes) {
-        if (processed++ > MAX_PROCESS)
-            break;
-        if (candidates.length >= MAX_CANDIDATES)
-            break;
-        const node = "node" in nodeItem ? nodeItem.node : nodeItem;
-        const view = node.ownerDocument?.defaultView;
-        if (!view || !(node instanceof view.Element))
-            continue;
-        if (isLowQualityNode(node))
-            continue;
-        const anchorStages = [
-            () => (0, xpathHelpers_js_1.getUniqueNodeAnchorXpaths)(node, docmt, isTarget, platform),
-            () => {
-                const anchors = [];
-                const element = node;
-                const attributes = Array.from(element.attributes || []).filter((attr) => attr.value &&
-                    !/\d/.test(attr.value) &&
-                    (0, xpathHelpers_js_1.checkBlockedAttributes)(attr, element, isTarget));
-                for (const attr of attributes) {
-                    const value = attr.value;
-                    if (!value)
-                        continue;
-                    const containsXpath = (0, xpathHelpers_js_1.getContainsPropertyXPath)(node, `@${attr.name}`, value, platform);
-                    if (containsXpath) {
-                        anchors.push({ key: "contains", value: containsXpath });
-                    }
-                    const startsWithXpath = (0, xpathHelpers_js_1.getStartsWithPropertyXPath)(node, `@${attr.name}`, value, platform);
-                    if (startsWithXpath) {
-                        anchors.push({ key: "starts-with", value: startsWithXpath });
-                    }
-                }
-                return anchors;
-            },
-            () => [{ key: "tag", value: (0, xpathHelpers_js_1.getTagOnlyXPath)(node, platform, docmt) }]
-        ];
-        for (let stageIndex = 0; stageIndex < anchorStages.length; stageIndex++) {
-            let anchors = anchorStages[stageIndex]();
-            if (!anchors.length)
-                continue;
-            if (!isIndex) {
-                anchors = anchors.filter((a) => !/\[\d+\]/.test(a.value));
-            }
-            const seen = new Set();
-            anchors = anchors.filter((a) => {
-                if (seen.has(a.value))
-                    return false;
-                seen.add(a.value);
-                return true;
-            });
-            anchors = anchors.slice(0, 5);
-            for (const anchor of anchors) {
-                const xpath = `${anchor.value}/${axis}::${targetNodeTest}`;
-                if ((0, xpathHelpers_js_1.isExactUniqueXpath)(xpath, targetElement, docmt)) {
-                    candidates.push({ key, value: xpath });
-                    if (candidates.length >= 2) {
-                        return candidates;
-                    }
-                    if (candidates.length >= MAX_CANDIDATES) {
-                        return candidates;
-                    }
-                }
-            }
-            if (isIndex && stageIndex === anchorStages.length - 1) {
-                for (const anchor of anchors) {
-                    const count = (0, xpathHelpers_js_1.getCountOfXPath)(anchor.value, node, docmt);
-                    for (let i = 1; i <= Math.min(count, MAX_INDEX_TRY); i++) {
-                        const xpath = `(${anchor.value})[${i}]/${axis}::${targetNodeTest}`;
-                        if ((0, xpathHelpers_js_1.isExactUniqueXpath)(xpath, targetElement, docmt)) {
-                            candidates.push({ key, value: xpath });
-                            if (candidates.length >= 2) {
-                                return candidates;
-                            }
-                            if (candidates.length >= MAX_CANDIDATES) {
-                                return candidates;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if ("expand" in nodeItem && nodeItem.expand) {
-            const expanded = nodeItem.expand();
-            let childCount = 0;
-            for (const child of expanded) {
-                if (childCount++ > 15)
-                    break;
-                if (candidates.length >= MAX_CANDIDATES)
-                    break;
-                const view = child.ownerDocument?.defaultView;
-                if (!view || !(child instanceof view.Element))
-                    continue;
-                if (isLowQualityNode(child))
-                    continue;
-                const anchors = (0, xpathHelpers_js_1.getUniqueNodeAnchorXpaths)(child, docmt, isTarget, platform);
-                for (const anchor of anchors.slice(0, 5)) {
-                    const xpath = `${anchor.value}/${axis}::${targetNodeTest}`;
-                    if ((0, xpathHelpers_js_1.isExactUniqueXpath)(xpath, targetElement, docmt)) {
-                        candidates.push({ key, value: xpath });
-                        if (candidates.length >= 2) {
-                            return candidates;
-                        }
-                        if (candidates.length >= MAX_CANDIDATES) {
-                            return candidates;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return candidates;
-};
-const buildAxesStrategyXpaths = (element, docmt, isTarget, isIndex, platform) => {
-    const ancestors = [];
-    for (let currentNode = element.parentElement; currentNode; currentNode = currentNode.parentElement) {
-        ancestors.push(currentNode);
-    }
-    const descendants = collectSubtreeElements(element);
-    const previousSiblings = getSiblingNodes(element, "previous");
-    const nextSiblings = getSiblingNodes(element, "next");
-    const precedingSeeds = getDirectionalAxisSeedNodes(element, "previous");
-    const followingSeeds = getDirectionalAxisSeedNodes(element, "next");
-    const limitNodes = (nodes, limit = 20) => {
-        return nodes.length > limit ? nodes.slice(0, limit) : nodes;
-    };
-    const tiers = [
-        [
-            {
-                nodes: limitNodes(nextSiblings),
-                axis: "preceding-sibling",
-                key: "preceding-sibling"
-            },
-            {
-                nodes: limitNodes(previousSiblings),
-                axis: "following-sibling",
-                key: "following-sibling"
-            }
-        ],
-        [
-            { nodes: limitNodes(ancestors), axis: "child", key: "child" },
-            {
-                nodes: limitNodes(descendants, 15),
-                axis: "parent",
-                key: "parent"
-            }
-        ],
-        [
-            { nodes: limitNodes(ancestors), axis: "descendant", key: "descendant" },
-            {
-                nodes: limitNodes(ancestors),
-                axis: "descendant-or-self",
-                key: "descendant-or-self"
-            },
-            {
-                nodes: limitNodes(descendants, 10),
-                axis: "ancestor",
-                key: "ancestor"
-            },
-            {
-                nodes: limitNodes(descendants, 10),
-                axis: "ancestor-or-self",
-                key: "ancestor-or-self"
-            }
-        ],
-        [
-            {
-                nodes: limitNodes(precedingSeeds),
-                axis: "following",
-                key: "following"
-            },
-            { nodes: limitNodes(followingSeeds), axis: "preceding", key: "preceding" }
-        ]
-    ];
-    for (const tier of tiers) {
-        for (const strategy of tier) {
-            const results = buildAxisXpathsForNodes(strategy.nodes, strategy.axis, element, docmt, isTarget, strategy.key, isIndex, platform);
-            if (results.length > 0) {
-                return results;
-            }
-        }
-    }
-    return [];
-};
-const generateIndexedXpaths = (element, docmt, platform) => {
-    const results = [];
-    const tag = platform === "web"
-        ? element.tagName.toLowerCase()
-        : element.tagName;
-    const globalList = Array.from(docmt.querySelectorAll(tag));
-    const idx = globalList.indexOf(element) + 1;
-    if (idx <= 0)
-        return [];
-    results.push({
-        key: "xpath by index",
-        value: `(//${tag})[${idx}]`
-    });
-    let current = element.parentElement;
-    while (current && current !== docmt.body) {
-        if (current.id || current.className) {
-            const cls = current.className
-                ?.toString()
-                .split(" ")
-                .map((name) => name.trim())
-                .find(Boolean);
-            const tagName = platform === "web"
-                ? current.tagName.toLowerCase()
-                : current.tagName;
-            const scopeXpath = current.id
-                ? `//${tagName}[@id='${current.id}']`
-                : cls
-                    ? `//${tagName}[contains(@class,'${cls}')]`
-                    : "";
-            if (!scopeXpath) {
-                current = current.parentElement;
-                continue;
-            }
-            const scopedDescendants = Array.from(current.querySelectorAll(tag));
-            const scopedIdx = scopedDescendants.indexOf(element) + 1;
-            if (scopedIdx > 0) {
-                results.push({
-                    key: "xpath by index",
-                    value: `(${scopeXpath}//${tag})[${scopedIdx}]`
-                });
-                break;
-            }
-        }
-        current = current.parentElement;
-    }
-    return results;
-};
-exports.generateIndexedXpaths = generateIndexedXpaths;
-const buildStrategyXpaths = (element, docmt, isTarget, strategy, platform) => {
-    const strategyName = getStrategyName(strategy);
-    if (strategyName === "text") {
-        return withStrategyKey(strategy, buildTextStrategyXpaths(element, docmt, strategyName, platform));
-    }
-    if (["contains", "startsWith", "normalizeSpace"].includes(strategyName)) {
-        return withStrategyKey(strategy, buildPropertyStrategyXpaths(element, isTarget, strategyName, platform));
-    }
-    if (["and", "or"].includes(strategyName)) {
-        return withStrategyKey(strategy, buildConditionStrategyXpaths(element, docmt, isTarget, strategyName, platform));
-    }
-    if (strategyName === "axes") {
-        return withStrategyKey(strategy, buildAxesStrategyXpaths(element, docmt, isTarget, false, platform));
-    }
-    if (strategyName === "index") {
-        return withStrategyKey(strategy, (0, exports.generateIndexedXpaths)(element, docmt, platform));
-    }
-    if (strategyName === "tag") {
-        return withStrategyKey(strategy, [
-            { key: "xpath till tag", value: (0, xpathHelpers_js_1.getTagOnlyXPath)(element, platform, docmt) }
-        ]);
+const checkAiRelativeXpathRelation = (nodeXpath1, nodeXpath2, targetElemt, docmt, relationType) => {
+    if (hasReachedRelativeXpathLimit()) {
+        return;
     }
-    return [];
-};
-const checkRelativeXpathRelation = (nodeXpath1, nodeXpath2, targetElemt, docmt, isIndex, relationType) => {
     if (nodeXpath1 && !referenceElementMode) {
         let xpaths;
         if (relationType === "parent") {
@@ -453,49 +82,18 @@ const checkRelativeXpathRelation = (nodeXpath1, nodeXpath2, targetElemt, docmt,
             // Check if result is already cached to avoid recomputation
             if (!xpathCache?.get(xpath)) {
                 // Compute and store result in cache
-                xpathCache.set(xpath, (0, xpathHelpers_js_1.getCountOfXPath)(xpath, targetElemt, docmt));
+                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;
             }
-            if (count > 1) {
-                if (xpathDataWithIndex.length) {
-                    if (count < xpathDataWithIndex[0].count) {
-                        xpathDataWithIndex.pop();
-                        xpathDataWithIndex.push({
-                            key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
-                            value: xpath,
-                            count
-                        });
-                    }
-                }
-                else {
-                    xpathDataWithIndex.push({
-                        key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
-                        value: xpath,
-                        count
-                    });
-                }
-            }
-            if (count > 1 && isIndex && !xpathData.length) {
-                // Try finding XPath with index if count is greater than 1
-                const indexedXpath = (0, xpathHelpers_js_1.findXpathWithIndex)(xpath, targetElemt, docmt, count);
-                // Cache the indexed XPath result
-                if (indexedXpath &&
-                    (0, xpathHelpers_js_1.getCountOfXPath)(indexedXpath, targetElemt, docmt) === 1) {
-                    xpathData.push({
-                        key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
-                        value: indexedXpath
-                    });
-                }
-            }
         }
     }
     return null;
 };
-const getUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, isIndex, platform) => {
+const getAiUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, _platform) => {
     try {
         if (parentXpathCache.has(domNode)) {
             return parentXpathCache.get(domNode);
@@ -504,19 +102,38 @@ const getUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, isIndex
         const xpathParts = [];
         let currentNode = domNode;
         while (currentNode && currentNode.nodeType === 1) {
-            const hasUniqueAttr = false;
-            for (const attrName of Array.from(currentNode.attributes)) {
-                if ((0, xpathHelpers_js_1.checkBlockedAttributes)(attrName, currentNode, isTarget)) {
-                    const attrValue = (0, xpathHelpers_js_1.sanitizeAttributeValue)(attrName.name, attrName.nodeValue);
+            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.getXpathString)(currentNode, elementName, attrValue);
+                    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 = checkRelativeXpathRelation(xpathe, nodeXpath, node, docmt, isIndex, "parent");
+                        othersWithAttr = checkAiRelativeXpathRelation(xpathe, nodeXpath, node, docmt, "parent");
                     }
                     catch (ign) {
-                        logData_js_1.logger.error("error in getUniqueParentXpath", ign);
+                        logData_js_1.logger.error("error in getAiUniqueParentXpath", ign);
                         continue;
                     }
                     // If the attribute isn't actually unique, get it's index too
@@ -525,21 +142,22 @@ const getUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, isIndex
                     }
                 }
             }
-            if (currentNode.textContent && !currentNode.textContent) {
+            const text = getCachedFilteredText(currentNode);
+            if (text) {
                 if (!isTarget ||
-                    (isTarget && !(0, xpathHelpers_js_1.isNumberExist)(currentNode.textContent))) {
+                    (isTarget && !(0, xpathHelpers_js_1.isAiNumberExist)(text))) {
                     let xpathe;
                     if (!xpathHelpers_js_1.reWhiteSpace.test(currentNode.textContent)) {
-                        xpathe = (0, xpathHelpers_js_1.isSvg)(currentNode)
-                            ? `//*[local-name()='${currentNode.tagName}' and normalize-space(.)=${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.getFilteredText)(currentNode))}]`
-                            : `//${currentNode.tagName || "*"}[normalize-space(.)=${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.getFilteredText)(currentNode))}]`;
+                        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.isSvg)(currentNode)
-                            ? `//*[local-name()='${currentNode.tagName}' and .=${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.getFilteredText)(currentNode))}]`
-                            : `//${currentNode.tagName || "*"}[.=${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.getFilteredText)(currentNode))}]`;
+                        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 = checkRelativeXpathRelation(xpathe, nodeXpath, node, docmt, isIndex, "parent");
+                    const othersWithAttr = checkAiRelativeXpathRelation(xpathe, nodeXpath, node, docmt, "parent");
                     if (othersWithAttr) {
                         return othersWithAttr;
                     }
@@ -547,26 +165,26 @@ const getUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, isIndex
                 else {
                     const combinePattern = [];
                     const contentRes = [
-                        ...new Set((0, xpathHelpers_js_1.getFilteredText)(currentNode).match(/([^0-9]+)/g))
+                        ...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.replaceWhiteSpaces)(contentRes[i].trim())) {
+                            if (contentRes[i] && (0, xpathHelpers_js_1.aiReplaceWhiteSpaces)(contentRes[i].trim())) {
                                 if (!reWhiteSpace.test(contentRes[i])) {
-                                    combinePattern.push(`contains(.,${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.replaceWhiteSpaces)(contentRes[i])).trim()})`);
+                                    combinePattern.push(`contains(.,${(0, xpathHelpers_js_1.escapeAiCharacters)((0, xpathHelpers_js_1.aiReplaceWhiteSpaces)(contentRes[i])).trim()})`);
                                 }
                                 else {
-                                    combinePattern.push(`contains(.,${(0, xpathHelpers_js_1.escapeCharacters)(contentRes[i].trim()).trim()})`);
+                                    combinePattern.push(`contains(.,${(0, xpathHelpers_js_1.escapeAiCharacters)(contentRes[i].trim()).trim()})`);
                                 }
                             }
                         }
                     }
                     if (combinePattern?.length) {
-                        const xpathe = (0, xpathHelpers_js_1.isSvg)(currentNode)
+                        const xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
                             ? `//*[local-name()='${currentNode.tagName}' and ${combinePattern.join(" and ")}]`
                             : `//${currentNode.tagName || "*"}[${combinePattern.join(" and ")}]`;
-                        const othersWithAttr = checkRelativeXpathRelation(xpathe, nodeXpath, node, docmt, isIndex, "parent");
+                        const othersWithAttr = checkAiRelativeXpathRelation(xpathe, nodeXpath, node, docmt, "parent");
                         if (othersWithAttr) {
                             return othersWithAttr;
                         }
@@ -574,28 +192,16 @@ const getUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, isIndex
                 }
             }
             // Construct the XPath based on the tag name
-            if (!hasUniqueAttr) {
-                const fallback = (0, xpathHelpers_js_1.getPlatformFallbackXpath)(currentNode, platform);
-                if (fallback) {
-                    const xpath = checkRelativeXpathRelation(fallback, nodeXpath, node, docmt, isIndex, "parent");
-                    if (xpath) {
-                        return xpath;
-                    }
-                }
-                const xpathe = (0, xpathHelpers_js_1.isSvg)(currentNode)
-                    ? `/*[local-name()='${currentNode.tagName}']`
-                    : `/${currentNode.tagName}`;
-                xpathParts.unshift(xpathe);
-            }
-            else {
-                break;
-            }
+            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 = (0, xpathHelpers_js_1.getCountOfXPath)(finalXPath, domNode, docmt);
+        const count = getCachedXPathCount(finalXPath, domNode, docmt);
         if (count === 1) {
             parentXpathCache.set(domNode, finalXPath); // Cache final result
             return finalXPath;
@@ -606,33 +212,52 @@ const getUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, isIndex
         return null;
     }
 };
-const getParentRelativeXpath = (domNode, docmt, node, isTarget, platform) => {
-    const cache = new Map(); // Cache to store computed results
-    if (cache.has(domNode)) {
-        return cache.get(domNode); // Return cached result if available
+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;
-            for (const attr of Array.from(currentNode.attributes)) {
-                if ((0, xpathHelpers_js_1.checkBlockedAttributes)(attr, currentNode, isTarget)) {
-                    const attrValue = (0, xpathHelpers_js_1.sanitizeAttributeValue)(attr.name, attr.nodeValue);
+            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.getXpathString)(currentNode, elementName, attrValue);
+                    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 = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, currentNode, docmt);
+                        othersWithAttr = getCachedXPathCount(xpathe, currentNode, docmt);
                     }
                     catch (ign) {
-                        logData_js_1.logger.error("error in getParentRelativeXpath", ign);
+                        logData_js_1.logger.error("error in getAiParentRelativeXpath", ign);
                         continue;
                     }
                     // If the attribute is unique, return its XPath
@@ -644,10 +269,10 @@ const getParentRelativeXpath = (domNode, docmt, node, isTarget, platform) => {
                 }
             }
             // If no unique attributes, check for text content
-            if (!uniqueAttrFound && currentNode.textContent && !node.textContent) {
-                const textXPath = (0, xpathHelpers_js_1.getFilteredTextXPath)(currentNode);
+            if (!uniqueAttrFound && !currentNode.textContent && !node.textContent) {
+                const textXPath = (0, xpathHelpers_js_1.getAiFilteredTextXPath)(currentNode);
                 if (textXPath) {
-                    const othersWithAttr = (0, xpathHelpers_js_1.getCountOfXPath)(textXPath, currentNode, docmt);
+                    const othersWithAttr = getCachedXPathCount(textXPath, currentNode, docmt);
                     if (othersWithAttr === 1) {
                         uniqueAttrFound = true; // Mark that we found at least one unique attribute
                         xpathParts.unshift(textXPath);
@@ -656,14 +281,8 @@ const getParentRelativeXpath = (domNode, docmt, node, isTarget, platform) => {
                 }
             }
             if (!uniqueAttrFound) {
-                const fallback = (0, xpathHelpers_js_1.getPlatformFallbackXpath)(currentNode, platform);
-                if (fallback) {
-                    xpathParts.push(fallback);
-                    uniqueAttrFound = true;
-                    break;
-                }
                 // Construct the XPath based on the tag name
-                const xpathe = (0, xpathHelpers_js_1.isSvg)(currentNode)
+                const xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
                     ? `/*[local-name()='${currentNode.tagName}']`
                     : `/${currentNode.tagName}`;
                 // Prepend the current XPath part to the array
@@ -685,7 +304,7 @@ const getParentRelativeXpath = (domNode, docmt, node, isTarget, platform) => {
         return null;
     }
 };
-const getChildRelativeXpath = (domNode, docmt, node) => {
+const getAiChildRelativeXpath = (domNode, docmt, node) => {
     const xpathParts = []; // Initialize an array to hold parts of the XPath.
     let currentNode;
     const st = [];
@@ -700,21 +319,45 @@ const getChildRelativeXpath = (domNode, docmt, node) => {
             st.unshift(m.nextElementSibling);
     }
     try {
+        let processedNodes = 0;
         do {
             let uniqueAttrFound = false;
             for (currentNode = st.pop(); currentNode !== null;) {
-                for (const attr of Array.from(currentNode.attributes)) {
-                    if ((0, xpathHelpers_js_1.checkBlockedAttributes)(attr, currentNode, true)) {
-                        const attrValue = (0, xpathHelpers_js_1.sanitizeAttributeValue)(attr.name, attr.nodeValue);
+                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.getXpathString)(currentNode, elementName, attrValue);
+                        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 = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, currentNode, docmt);
+                            othersWithAttr = getCachedXPathCount(xpathe, currentNode, docmt);
                         }
                         catch (ign) {
-                            logData_js_1.logger.error("error in getChildRelativeXpath", ign);
+                            logData_js_1.logger.error("error in getAiChildRelativeXpath", ign);
                             continue;
                         }
                         // If the attribute is unique, return its XPath
@@ -727,9 +370,9 @@ const getChildRelativeXpath = (domNode, docmt, node) => {
                 }
                 // If no unique attributes, check for text content
                 if (!uniqueAttrFound && currentNode.textContent && !node.textContent) {
-                    const textXPath = (0, xpathHelpers_js_1.getFilteredTextXPath)(currentNode);
+                    const textXPath = (0, xpathHelpers_js_1.getAiFilteredTextXPath)(currentNode);
                     if (textXPath) {
-                        const othersWithAttr = (0, xpathHelpers_js_1.getCountOfXPath)(textXPath, currentNode, docmt);
+                        const othersWithAttr = getCachedXPathCount(textXPath, currentNode, docmt);
                         if (othersWithAttr === 1) {
                             uniqueAttrFound = true; // Mark that we found at least one unique attribute
                             xpathParts.push(textXPath);
@@ -739,7 +382,7 @@ const getChildRelativeXpath = (domNode, docmt, node) => {
                 }
                 if (!uniqueAttrFound) {
                     // Construct the XPath based on the tag name
-                    const xpathe = (0, xpathHelpers_js_1.isSvg)(currentNode)
+                    const xpathe = (0, xpathHelpers_js_1.isAiSvg)(currentNode)
                         ? `/*[local-name()='${currentNode.tagName}']`
                         : `/${currentNode.tagName}`;
                     // Prepend the current XPath part to the array
@@ -763,121 +406,114 @@ const getChildRelativeXpath = (domNode, docmt, node) => {
         return finalXpath;
     }
     catch (error) {
-        logData_js_1.logger.error("error in getChildRelativeXpath", error);
+        logData_js_1.logger.error("error in getAiChildRelativeXpath", error);
         return null;
     }
 };
-const getSiblingRelativeXPath = (domNode, docmt, isTarget, nodeXpath, platform) => {
+const getAiSiblingRelativeXPath = (domNode, docmt, isTarget, nodeXpath, platform) => {
     try {
-        const markedSpan = document.querySelector(".flntooltip");
+        const markedSpan = domNode.ownerDocument?.querySelector(".flntooltip");
         for (let m = domNode.nextElementSibling; m !== null && m !== markedSpan; m = m.nextElementSibling) {
-            processSibling(m, domNode, docmt, nodeXpath, "preceding-sibling", isTarget, platform);
+            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) {
-            processSibling(n, domNode, docmt, nodeXpath, "following-sibling", isTarget, platform);
+            if (hasReachedRelativeXpathLimit()) {
+                return;
+            }
+            processAiSibling(n, domNode, docmt, nodeXpath, "following-sibling", isTarget, platform);
         }
     }
-    catch (error) {
-        console.error("sibling error", error);
+    catch {
         return null;
     }
 };
-const processSibling = (sibling, domNode, docmt, nodeXpath, axis, isTarget, platform) => {
+const processAiSibling = (sibling, domNode, docmt, nodeXpath, axis, isTarget, _platform) => {
     try {
+        if (hasReachedRelativeXpathLimit()) {
+            return;
+        }
         if (sibling.hasAttributes()) {
-            for (const attr of Array.from(sibling.attributes)) {
-                let xpathe = (0, xpathHelpers_js_1.intermediateXpathStep)(sibling, {
+            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 = (0, xpathHelpers_js_1.getPlatformFallbackXpath)(sibling, platform);
-                }
                 if (xpathe) {
                     xpathe += `/${axis}::${nodeXpath}`;
-                    const count = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, sibling, docmt);
+                    const count = getCachedXPathCount(xpathe, sibling, docmt);
                     if (count === 1) {
-                        xpathData.push({
+                        if (!appendXPath(xpathData, {
                             key: `xpath by ${axis}`,
                             value: xpathe
-                        });
-                        return;
-                    }
-                    else if (count > 1) {
-                        if (xpathDataWithIndex.length) {
-                            if (count < xpathDataWithIndex[0].count) {
-                                xpathDataWithIndex.pop();
-                                xpathDataWithIndex.push({
-                                    key: `relative xpath by ${axis}`,
-                                    value: xpathe,
-                                    count
-                                });
-                            }
+                        })) {
+                            return;
                         }
-                        else {
-                            xpathDataWithIndex.push({
-                                key: `relative xpath by ${axis}`,
-                                value: xpathe,
-                                count
-                            });
+                        if (hasReachedRelativeXpathLimit()) {
+                            return;
                         }
                     }
                 }
             }
         }
         if (!isTarget) {
-            const xpathe = (0, xpathHelpers_js_1.intermediateXpathStep)(sibling, {
+            const xpathe = (0, xpathHelpers_js_1.intermediateAiXpathStep)(sibling, {
                 name: "text",
-                value: sibling.textContent
+                value: getCachedTextContent(sibling)
             }, isTarget);
             if (xpathe) {
-                const count = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, sibling, docmt);
+                const count = getCachedXPathCount(xpathe, sibling, docmt);
                 if (count === 1) {
-                    xpathData.push({
+                    if (!appendXPath(xpathData, {
                         key: `xpath by ${axis}`,
                         value: xpathe
-                    });
-                    return;
-                }
-                else if (count > 1) {
-                    if (xpathDataWithIndex.length) {
-                        if (count < xpathDataWithIndex[0].count) {
-                            xpathDataWithIndex.pop();
-                            xpathDataWithIndex.push({
-                                key: `relative xpath by ${axis}`,
-                                value: xpathe,
-                                count
-                            });
-                        }
-                    }
-                    else {
-                        xpathDataWithIndex.push({
-                            key: `relative xpath by ${axis}`,
-                            value: xpathe,
-                            count
-                        });
+                    })) {
+                        return;
                     }
+                    return;
                 }
             }
         }
     }
     catch (error) {
-        logData_js_1.logger.error(`${axis} xpath-error`, error);
+        logData_js_1.logger.error(`${axis} xpath-error`, error.message);
     }
 };
-function getXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget) {
+function getAiXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget) {
     const { tagName } = targetElemt;
-    const textContent = targetElemt.textContent.trim();
+    const textContent = getCachedTextContent(targetElemt);
     if (!textContent) {
         return;
     }
     for (const attrName of attributes) {
-        if ((0, xpathHelpers_js_1.checkBlockedAttributes)(attrName, targetElemt, isTarget)) {
-            const attrValue = (0, xpathHelpers_js_1.sanitizeAttributeValue)(attrName.name, attrName.nodeValue);
+        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 = (0, xpathHelpers_js_1.getCountOfXPath)(xpath, targetElemt, docmt);
+                const count = getCachedXPathCount(xpath, targetElemt, docmt);
                 if (count == 1) {
                     return xpath;
                 }
@@ -885,225 +521,124 @@ function getXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget)
         }
     }
 }
-const addRelativeXpaths = (targetElemt, docmt, isIndex, isTarget, attribute, platform) => {
-    try {
-        const nodeXpath = [];
-        let relativeXpath, relativeChildXpath;
-        xpathData = [];
-        if (attribute) {
-            for (const attrName of attribute) {
-                const expression = (0, xpathHelpers_js_1.intermediateXpathStep)(targetElemt, {
-                    name: attrName.name,
-                    value: attrName.value
-                }, isTarget);
-                if (expression) {
-                    nodeXpath.push(expression);
-                }
-            }
-        }
-        if (targetElemt.textContent) {
-            const expression = (0, xpathHelpers_js_1.intermediateXpathStep)(targetElemt, {
-                name: "text",
-                value: targetElemt.textContent
-            }, isTarget);
-            // console.log(expression);
-            if (expression) {
-                nodeXpath.push(expression);
-            }
-        }
-        nodeXpath.push(targetElemt.tagName);
-        if (nodeXpath?.length) {
-            for (let i = 0; i < nodeXpath.length; i++) {
-                if (!xpathData.length) {
-                    getSiblingRelativeXPath(targetElemt, docmt, isTarget, nodeXpath[i], platform);
-                    if (!xpathData.length) {
-                        if (!relativeXpath) {
-                            relativeXpath = getParentRelativeXpath(targetElemt.parentElement, docmt, targetElemt, isTarget, platform);
-                        }
-                        if (relativeXpath &&
-                            (relativeXpath.includes("@") ||
-                                relativeXpath.includes("text()") ||
-                                relativeXpath.includes(".=")) &&
-                            relativeXpath.match(/\//g)?.length - 2 < 5) {
-                            const fullRelativeXpath = relativeXpath + `/${nodeXpath[i]}`;
-                            const count = (0, xpathHelpers_js_1.getCountOfXPath)(fullRelativeXpath, targetElemt, docmt);
-                            if (count === 1) {
-                                xpathData.push({
-                                    key: "relative xpath by relative parent",
-                                    value: fullRelativeXpath
-                                });
-                            }
-                            else if (count > 1 && isIndex) {
-                                const relativeXpathIndex = (0, xpathHelpers_js_1.findXpathWithIndex)(fullRelativeXpath, targetElemt, docmt, count);
-                                if (relativeXpathIndex &&
-                                    (0, xpathHelpers_js_1.getCountOfXPath)(relativeXpathIndex, targetElemt, docmt) === 1) {
-                                    xpathData.push({
-                                        key: `relative xpath by relative parent  ${isIndex ? "index" : ""}`,
-                                        value: relativeXpathIndex
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    if (xpathData.length <= 1) {
-                        if (!relativeChildXpath) {
-                            relativeChildXpath = getChildRelativeXpath(targetElemt, docmt, targetElemt);
-                        }
-                        if (relativeChildXpath &&
-                            (relativeChildXpath.includes("@") ||
-                                relativeChildXpath.includes("text()") ||
-                                relativeChildXpath.includes(".="))) {
-                            const fullRelativeXpath = `/${nodeXpath[i] + relativeChildXpath.substring(1)}`;
-                            const count = (0, xpathHelpers_js_1.getCountOfXPath)(fullRelativeXpath, targetElemt, docmt);
-                            if (count === 1) {
-                                xpathData.push({
-                                    key: "relative xpath by relative child",
-                                    value: fullRelativeXpath
-                                });
-                            }
-                            else if (count > 1 && isIndex) {
-                                const relativeXpathIndex = (0, xpathHelpers_js_1.findXpathWithIndex)(fullRelativeXpath, targetElemt, docmt, count);
-                                if (relativeXpathIndex &&
-                                    (0, xpathHelpers_js_1.getCountOfXPath)(relativeXpathIndex, targetElemt, docmt) === 1) {
-                                    xpathData.push({
-                                        key: `relative xpath by relative parent  ${isIndex ? "index" : ""}`,
-                                        value: relativeXpathIndex
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    if (xpathData?.length === 1 &&
-                        (xpathData?.[0]?.value?.match(/\[([0-9]+)\]/gm)?.length || 0) > 3 &&
-                        !referenceElementMode) {
-                        if (targetElemt.textContent) {
-                            const txtXpath = (0, exports.getTextXPath)(targetElemt, docmt, isIndex, false, platform);
-                            if (txtXpath) {
-                                xpathData.unshift({
-                                    key: `xpath by text${isIndex ? "index" : ""}`,
-                                    value: txtXpath
-                                });
-                            }
-                        }
-                    }
-                    if (!xpathData.length) {
-                        const tempRelativeXpath = getUniqueParentXpath(targetElemt.parentElement, docmt, targetElemt, isTarget, nodeXpath[i], isIndex, platform);
-                        if (tempRelativeXpath) {
-                            xpathData.push({
-                                key: "xpath by unique parent",
-                                value: tempRelativeXpath
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        return xpathData;
-    }
-    catch (error) {
-        logData_js_1.logger.error("Error in addRelativeXpaths:", error);
-    }
-};
-const attributesBasedXPath = (attr, targetElemt, docmt, isIndex, isTarget, platform) => {
+const attributesAiBasedXPath = (attr, targetElemt, docmt, isTarget, platform) => {
     const attrName = attr.name;
-    const xpath = (0, xpathHelpers_js_1.getPropertyXPath)(targetElemt, docmt, `@${attrName}`, attr.value, isIndex, isTarget, platform);
+    const xpath = (0, xpathHelpers_js_1.getAiPropertyXPath)(targetElemt, docmt, `@${attrName}`, attr.value, isTarget, platform);
     return xpath;
 };
-exports.attributesBasedXPath = attributesBasedXPath;
-const getUniqueClassName = (element, docmt, isIndex, isTarget, platform) => {
+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.sanitizeAttributeValue)("class", value);
+    value = (0, xpathHelpers_js_1.sanitizeAiAttributeValue)("class", value);
     value = value?.trim();
     if (value) {
-        return (0, xpathHelpers_js_1.getPropertyXPath)(element, docmt, `@class`, value, isIndex, isTarget, platform);
+        return (0, xpathHelpers_js_1.getAiPropertyXPath)(element, docmt, `@class`, value, isTarget, platform);
     }
 };
-exports.getUniqueClassName = getUniqueClassName;
-const getTextXPath = (element, docmt, isIndex, isTarget, platform) => {
+exports.getAiUniqueClassName = getAiUniqueClassName;
+const getAiTextXPath = (element, docmt, isTarget, platform) => {
     if ((element.textContent ?? "").trim() != "") {
-        const text = (0, xpathHelpers_js_1.getTextContent)(element);
+        const text = getCachedTextContent(element);
         if (text) {
-            return (0, xpathHelpers_js_1.getPropertyXPath)(element, docmt, ".", text, isIndex, isTarget, platform);
+            return (0, xpathHelpers_js_1.getAiPropertyXPath)(element, docmt, ".", text, isTarget, platform);
         }
     }
 };
-exports.getTextXPath = getTextXPath;
-const addAllXPathAttributes = (attributes, targetElemt, docmt, isIndex, 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.checkBlockedAttributes)(attr, targetElemt, isTarget)) {
-                    const xpth = (0, exports.attributesBasedXPath)(attr, targetElemt, docmt, isIndex, isTarget, platform);
+                if ((0, xpathHelpers_js_1.checkAiBlockedAttributes)(attr, targetElemt, isTarget)) {
+                    const xpth = (0, exports.attributesAiBasedXPath)(attr, targetElemt, docmt, isTarget, platform);
                     if (xpth) {
-                        xpathData.push({
-                            key: `xpath by ${attr.name}${isIndex ? " index" : ""}`,
+                        if (!appendXPath(xpathData, {
+                            key: `xpath by ${attr.name}`,
                             value: xpth
-                        });
+                        })) {
+                            return;
+                        }
                     }
-                    const containsXpath = (0, xpathHelpers_js_1.getContainsPropertyXPath)(targetElemt, `@${attr.name}`, attr.value, platform);
+                    const containsXpath = (0, xpathHelpers_js_1.getAiContainsPropertyXPath)(targetElemt, `@${attr.name}`, attr.value, platform);
                     if (containsXpath &&
-                        (0, xpathHelpers_js_1.getCountOfXPath)(containsXpath, targetElemt, docmt) === 1) {
-                        xpathData.push({
+                        getCachedXPathCount(containsXpath, targetElemt, docmt) === 1) {
+                        if (!appendXPath(xpathData, {
                             key: `xpath by contains ${attr.name}`,
                             value: containsXpath
-                        });
+                        })) {
+                            return;
+                        }
                     }
-                    const startsWithXpath = (0, xpathHelpers_js_1.getStartsWithPropertyXPath)(targetElemt, `@${attr.name}`, attr.value, platform);
+                    const startsWithXpath = (0, xpathHelpers_js_1.getAiStartsWithPropertyXPath)(targetElemt, `@${attr.name}`, attr.value, platform);
                     if (startsWithXpath &&
-                        (0, xpathHelpers_js_1.getCountOfXPath)(startsWithXpath, targetElemt, docmt) === 1) {
-                        xpathData.push({
+                        getCachedXPathCount(startsWithXpath, targetElemt, docmt) === 1) {
+                        if (!appendXPath(xpathData, {
                             key: `xpath by startsWith ${attr.name}`,
                             value: startsWithXpath
-                        });
+                        })) {
+                            return;
+                        }
                     }
                 }
             }
         });
-        const txtXpath = (0, exports.getTextXPath)(targetElemt, docmt, isIndex, isTarget, platform);
+        const txtXpath = (0, exports.getAiTextXPath)(targetElemt, docmt, isTarget, platform);
         if (txtXpath) {
-            xpathData.push({
-                key: `xpath by text${isIndex ? " index" : ""}`,
+            if (!appendXPath(xpathData, {
+                key: "xpath by text",
                 value: txtXpath
-            });
+            })) {
+                return;
+            }
         }
         const classNameAttr = attributesArray.find((element) => element.name === "className");
-        if (classNameAttr && (0, xpathHelpers_js_1.checkBlockedAttributes)(classNameAttr, targetElemt, isTarget)) {
-            const xpath = (0, exports.getUniqueClassName)(targetElemt, docmt, isIndex, isTarget, platform);
+        if (classNameAttr && (0, xpathHelpers_js_1.checkAiBlockedAttributes)(classNameAttr, targetElemt, isTarget)) {
+            const xpath = (0, exports.getAiUniqueClassName)(targetElemt, docmt, isTarget, platform);
             if (xpath) {
-                xpathData.push({
+                if (!appendXPath(xpathData, {
                     key: "xpath by class",
                     value: xpath
-                });
+                })) {
+                    return;
+                }
             }
         }
         if (!xpathData.length && attributesArray.length > 1) {
-            const combinationXpath = (0, xpathHelpers_js_1.getAttributeCombinationXpath)(targetElemt, docmt, attributesArray, isTarget, platform);
-            if (combinationXpath)
-                xpathData.push({
+            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 = getXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget);
-            if (textAttribute)
-                xpathData.push({
+            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 addAllXPathAttributes:", error);
+        logData_js_1.logger.error("Error in addAiAllXPathAttributes:", error);
     }
 };
-const parseDOM = (element, doc, isIndex, isTarget, includedAttributes = [], strategies = [], platform) => {
+const aiParseDOM = (element, doc, isTarget, includedAttributes = [], platform) => {
     xpathData = [];
+    xpathValues.clear();
+    xpathCache.clear();
     const targetElemt = element;
     const rootNode = targetElemt?.getRootNode?.();
     const DOCUMENT_FRAGMENT_NODE = 11;
@@ -1112,28 +647,29 @@ const parseDOM = (element, doc, isIndex, isTarget, includedAttributes = [], stra
     const tag = targetElemt.tagName;
     const { attributes } = targetElemt;
     const attributesToUse = includedAttributes.length > 0 ? includedAttributes : Array.from(attributes);
-    addAllXPathAttributes(attributesToUse, targetElemt, docmt, isIndex, isTarget, platform);
+    addAiAllXPathAttributes(attributesToUse, targetElemt, docmt, isTarget, platform);
+    if (xpathData.length >= MAX_XPATH_RESULTS) {
+        return xpathData;
+    }
     if (platform === "android") {
-        xpathData.push(...(0, androidSelector_js_1.generateAndroidLocators)(targetElemt, docmt, isTarget));
+        xpathData.push(...(0, androidSelector_js_1.generateAiAndroidLocators)(targetElemt, docmt, isTarget));
     }
     else if (platform === "ios") {
-        xpathData.push(...(0, iosSelector_js_1.generateIOSLocators)(targetElemt, docmt, isTarget));
+        xpathData.push(...(0, iosSelector_js_1.generateAiIOSLocators)(targetElemt, docmt, isTarget));
+    }
+    if (xpathData.length >= MAX_XPATH_RESULTS) {
+        return xpathData;
     }
-    if (xpathData.length < 2) {
-        const fallback = (0, xpathHelpers_js_1.getPlatformFallbackXpath)(targetElemt, platform);
-        if (fallback) {
-            xpathData.push({
-                key: "platform fallback",
-                value: fallback
+    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 (strategies.length) {
-        const strategyXpaths = strategies.flatMap((strategy) => buildStrategyXpaths(targetElemt, docmt, isTarget, strategy, platform));
-        xpathData = getUniqueXpathEntries(strategyXpaths.filter((xpath) => (0, xpathHelpers_js_1.getCountOfXPath)(xpath.value, targetElemt, docmt) === 1));
-        return xpathData;
-    }
-    if (!referenceElementMode) {
+    if (!referenceElementMode && xpathData.length < MAX_XPATH_RESULTS) {
         if (xpathData.length) {
             const len = xpathData.length;
             for (let i = 0; i < len; i++) {
@@ -1141,42 +677,34 @@ const parseDOM = (element, doc, isIndex, isTarget, includedAttributes = [], stra
                 if (xpth.startsWith(`//${tag}`)) {
                     xpth = "//*" + xpth.substring(2 + tag.length);
                 }
-                if ((0, xpathHelpers_js_1.getCountOfXPath)(xpth, element, docmt) === 1 &&
-                    !xpathData.some(x => x.value === xpth)) {
-                    xpathData.push({
+                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;
+                    }
                 }
-                // const count = getCountOfXPath(xpth, element, docmt);
-                // if (count === 1) {
-                //   xpathData.push({
-                //     key: `${xpathData[i].key} regex`,
-                //     value: xpth
-                //   });
-                // }
             }
         }
     }
-    if (!xpathData.length && !isShadowScoped) {
-        xpathData = buildAxesStrategyXpaths(targetElemt, docmt, isTarget, isIndex, platform);
-    }
     return xpathData;
 };
-exports.parseDOM = parseDOM;
+exports.aiParseDOM = aiParseDOM;
 const xpath = {
-    parseDOM: exports.parseDOM,
-    getTextXPath: exports.getTextXPath,
-    getUniqueClassName: exports.getUniqueClassName,
-    attributesBasedXPath: exports.attributesBasedXPath,
-    addAllXPathAttributes,
-    addRelativeXpaths,
-    getXPathUsingAttributeAndText,
-    getSiblingRelativeXPath,
-    getChildRelativeXpath,
-    getParentRelativeXpath,
-    getUniqueParentXpath,
-    checkRelativeXpathRelation,
-    buildAxesStrategyXpaths
+    aiParseDOM: exports.aiParseDOM,
+    getAiTextXPath: exports.getAiTextXPath,
+    getAiUniqueClassName: exports.getAiUniqueClassName,
+    attributesAiBasedXPath: exports.attributesAiBasedXPath,
+    addAiAllXPathAttributes,
+    getAiXPathUsingAttributeAndText,
+    getAiSiblingRelativeXPath,
+    getAiChildRelativeXpath,
+    getAiParentRelativeXpath,
+    getAiUniqueParentXpath,
+    checkAiRelativeXpathRelation
 };
 exports.default = xpath;