ff-automationv2 2.2.28 → 2.2.29

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

@@ -0,0 +1,1182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDOM = exports.getTextXPath = exports.getUniqueClassName = exports.attributesBasedXPath = exports.generateIndexedXpaths = 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 referenceElementMode = false;
+const xpathCache = new Map();
+const cache = new Map();
+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);
+        return true;
+    });
+};
+const getNormalizedText = (element) => {
+    return element?.textContent?.replace(/\s+/g, " ")?.trim() || "";
+};
+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
+            });
+        }
+    }
+    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 }] : [];
+    }
+    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 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 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) }
+        ]);
+    }
+    return [];
+};
+const checkRelativeXpathRelation = (nodeXpath1, nodeXpath2, targetElemt, docmt, isIndex, relationType) => {
+    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, (0, xpathHelpers_js_1.getCountOfXPath)(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) => {
+    try {
+        if (parentXpathCache.has(domNode)) {
+            return parentXpathCache.get(domNode);
+        }
+        // Direct XPath construction without loops
+        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);
+                    const elementName = attrName.name;
+                    const xpathe = (0, xpathHelpers_js_1.getXpathString)(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");
+                    }
+                    catch (ign) {
+                        logData_js_1.logger.error("error in getUniqueParentXpath", ign);
+                        continue;
+                    }
+                    // If the attribute isn't actually unique, get it's index too
+                    if (othersWithAttr) {
+                        return othersWithAttr;
+                    }
+                }
+            }
+            if (currentNode.textContent && !currentNode.textContent) {
+                if (!isTarget ||
+                    (isTarget && !(0, xpathHelpers_js_1.isNumberExist)(currentNode.textContent))) {
+                    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))}]`;
+                    }
+                    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))}]`;
+                    }
+                    const othersWithAttr = checkRelativeXpathRelation(xpathe, nodeXpath, node, docmt, isIndex, "parent");
+                    if (othersWithAttr) {
+                        return othersWithAttr;
+                    }
+                }
+                else {
+                    const combinePattern = [];
+                    const contentRes = [
+                        ...new Set((0, xpathHelpers_js_1.getFilteredText)(currentNode).match(/([^0-9]+)/g))
+                    ];
+                    const reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+                    if (contentRes?.length) {
+                        for (let i = 0; i < contentRes?.length; i++) {
+                            if (contentRes[i] && (0, xpathHelpers_js_1.replaceWhiteSpaces)(contentRes[i].trim())) {
+                                if (!reWhiteSpace.test(contentRes[i])) {
+                                    combinePattern.push(`contains(.,${(0, xpathHelpers_js_1.escapeCharacters)((0, xpathHelpers_js_1.replaceWhiteSpaces)(contentRes[i])).trim()})`);
+                                }
+                                else {
+                                    combinePattern.push(`contains(.,${(0, xpathHelpers_js_1.escapeCharacters)(contentRes[i].trim()).trim()})`);
+                                }
+                            }
+                        }
+                    }
+                    if (combinePattern?.length) {
+                        const xpathe = (0, xpathHelpers_js_1.isSvg)(currentNode)
+                            ? `//*[local-name()='${currentNode.tagName}' and ${combinePattern.join(" and ")}]`
+                            : `//${currentNode.tagName || "*"}[${combinePattern.join(" and ")}]`;
+                        const othersWithAttr = checkRelativeXpathRelation(xpathe, nodeXpath, node, docmt, isIndex, "parent");
+                        if (othersWithAttr) {
+                            return othersWithAttr;
+                        }
+                    }
+                }
+            }
+            // 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;
+            }
+            // 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);
+        if (count === 1) {
+            parentXpathCache.set(domNode, finalXPath); // Cache final result
+            return finalXPath;
+        }
+    }
+    catch (error) {
+        console.error(error);
+        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 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) {
+            // 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 elementName = attr.name;
+                    const xpathe = (0, xpathHelpers_js_1.getXpathString)(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);
+                    }
+                    catch (ign) {
+                        logData_js_1.logger.error("error in getParentRelativeXpath", 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.getFilteredTextXPath)(currentNode);
+                if (textXPath) {
+                    const othersWithAttr = (0, xpathHelpers_js_1.getCountOfXPath)(textXPath, currentNode, docmt);
+                    if (othersWithAttr === 1) {
+                        uniqueAttrFound = true; // Mark that we found at least one unique attribute
+                        xpathParts.unshift(textXPath);
+                        break;
+                    }
+                }
+            }
+            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)
+                    ? `/*[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 getChildRelativeXpath = (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 {
+        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);
+                        const elementName = attr.name;
+                        const xpathe = (0, xpathHelpers_js_1.getXpathString)(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);
+                        }
+                        catch (ign) {
+                            logData_js_1.logger.error("error in getChildRelativeXpath", 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.getFilteredTextXPath)(currentNode);
+                    if (textXPath) {
+                        const othersWithAttr = (0, xpathHelpers_js_1.getCountOfXPath)(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.isSvg)(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 getChildRelativeXpath", error);
+        return null;
+    }
+};
+const getSiblingRelativeXPath = (domNode, docmt, isTarget, nodeXpath, platform) => {
+    try {
+        const markedSpan = document.querySelector(".flntooltip");
+        for (let m = domNode.nextElementSibling; m !== null && m !== markedSpan; m = m.nextElementSibling) {
+            processSibling(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);
+        }
+    }
+    catch (error) {
+        console.error("sibling error", error);
+        return null;
+    }
+};
+const processSibling = (sibling, domNode, docmt, nodeXpath, axis, isTarget, platform) => {
+    try {
+        if (sibling.hasAttributes()) {
+            for (const attr of Array.from(sibling.attributes)) {
+                let xpathe = (0, xpathHelpers_js_1.intermediateXpathStep)(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);
+                    if (count === 1) {
+                        xpathData.push({
+                            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
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        if (!isTarget) {
+            const xpathe = (0, xpathHelpers_js_1.intermediateXpathStep)(sibling, {
+                name: "text",
+                value: sibling.textContent
+            }, isTarget);
+            if (xpathe) {
+                const count = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, sibling, docmt);
+                if (count === 1) {
+                    xpathData.push({
+                        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
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logData_js_1.logger.error(`${axis} xpath-error`, error);
+    }
+};
+function getXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget) {
+    const { tagName } = targetElemt;
+    const textContent = targetElemt.textContent.trim();
+    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);
+            const elementName = attrName.name;
+            const xpath = `//${tagName}[@${elementName}='${attrValue}' and text()='${textContent}']`;
+            if (xpath) {
+                const count = (0, xpathHelpers_js_1.getCountOfXPath)(xpath, targetElemt, docmt);
+                if (count == 1) {
+                    return xpath;
+                }
+            }
+        }
+    }
+}
+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 attrName = attr.name;
+    const xpath = (0, xpathHelpers_js_1.getPropertyXPath)(targetElemt, docmt, `@${attrName}`, attr.value, isIndex, isTarget, platform);
+    return xpath;
+};
+exports.attributesBasedXPath = attributesBasedXPath;
+const getUniqueClassName = (element, docmt, isIndex, 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 = value?.trim();
+    if (value) {
+        return (0, xpathHelpers_js_1.getPropertyXPath)(element, docmt, `@class`, value, isIndex, isTarget, platform);
+    }
+};
+exports.getUniqueClassName = getUniqueClassName;
+const getTextXPath = (element, docmt, isIndex, isTarget, platform) => {
+    if ((element.textContent ?? "").trim() != "") {
+        const text = (0, xpathHelpers_js_1.getTextContent)(element);
+        if (text) {
+            return (0, xpathHelpers_js_1.getPropertyXPath)(element, docmt, ".", text, isIndex, isTarget, platform);
+        }
+    }
+};
+exports.getTextXPath = getTextXPath;
+const addAllXPathAttributes = (attributes, targetElemt, docmt, isIndex, 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 (xpth) {
+                        xpathData.push({
+                            key: `xpath by ${attr.name}${isIndex ? " index" : ""}`,
+                            value: xpth
+                        });
+                    }
+                    const containsXpath = (0, xpathHelpers_js_1.getContainsPropertyXPath)(targetElemt, `@${attr.name}`, attr.value, platform);
+                    if (containsXpath &&
+                        (0, xpathHelpers_js_1.getCountOfXPath)(containsXpath, targetElemt, docmt) === 1) {
+                        xpathData.push({
+                            key: `xpath by contains ${attr.name}`,
+                            value: containsXpath
+                        });
+                    }
+                    const startsWithXpath = (0, xpathHelpers_js_1.getStartsWithPropertyXPath)(targetElemt, `@${attr.name}`, attr.value, platform);
+                    if (startsWithXpath &&
+                        (0, xpathHelpers_js_1.getCountOfXPath)(startsWithXpath, targetElemt, docmt) === 1) {
+                        xpathData.push({
+                            key: `xpath by startsWith ${attr.name}`,
+                            value: startsWithXpath
+                        });
+                    }
+                }
+            }
+        });
+        const txtXpath = (0, exports.getTextXPath)(targetElemt, docmt, isIndex, isTarget, platform);
+        if (txtXpath) {
+            xpathData.push({
+                key: `xpath by text${isIndex ? " index" : ""}`,
+                value: txtXpath
+            });
+        }
+        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 (xpath) {
+                xpathData.push({
+                    key: "xpath by class",
+                    value: xpath
+                });
+            }
+        }
+        if (!xpathData.length && attributesArray.length > 1) {
+            const combinationXpath = (0, xpathHelpers_js_1.getAttributeCombinationXpath)(targetElemt, docmt, attributesArray, isTarget, platform);
+            if (combinationXpath)
+                xpathData.push({
+                    key: "xpath by combination",
+                    value: combinationXpath
+                });
+        }
+        if (!xpathData.length) {
+            const textAttribute = getXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget);
+            if (textAttribute)
+                xpathData.push({
+                    key: "xpath by textAttribute",
+                    value: textAttribute
+                });
+        }
+    }
+    catch (error) {
+        logData_js_1.logger.error("Error in addAllXPathAttributes:", error);
+    }
+};
+const parseDOM = (element, doc, isIndex, isTarget, includedAttributes = [], strategies = [], platform) => {
+    xpathData = [];
+    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);
+    addAllXPathAttributes(attributesToUse, targetElemt, docmt, isIndex, isTarget, platform);
+    if (platform === "android") {
+        xpathData.push(...(0, androidSelector_js_1.generateAndroidLocators)(targetElemt, docmt, isTarget));
+    }
+    else if (platform === "ios") {
+        xpathData.push(...(0, iosSelector_js_1.generateIOSLocators)(targetElemt, docmt, isTarget));
+    }
+    if (xpathData.length < 2) {
+        const fallback = (0, xpathHelpers_js_1.getPlatformFallbackXpath)(targetElemt, platform);
+        if (fallback) {
+            xpathData.push({
+                key: "platform fallback",
+                value: fallback
+            });
+        }
+    }
+    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 (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 ((0, xpathHelpers_js_1.getCountOfXPath)(xpth, element, docmt) === 1 &&
+                    !xpathData.some(x => x.value === xpth)) {
+                    xpathData.push({
+                        key: `${xpathData[i].key} regex`,
+                        value: xpth
+                    });
+                }
+                // 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;
+const xpath = {
+    parseDOM: exports.parseDOM,
+    getTextXPath: exports.getTextXPath,
+    getUniqueClassName: exports.getUniqueClassName,
+    attributesBasedXPath: exports.attributesBasedXPath,
+    addAllXPathAttributes,
+    addRelativeXpaths,
+    getXPathUsingAttributeAndText,
+    getSiblingRelativeXPath,
+    getChildRelativeXpath,
+    getParentRelativeXpath,
+    getUniqueParentXpath,
+    checkRelativeXpathRelation,
+    buildAxesStrategyXpaths
+};
+exports.default = xpath;