ff-dom 1.0.17 → 1.0.18-beta.2

package/dist/index.cdn.js

@@ -0,0 +1,2775 @@
+(function (exports) {
+    'use strict';
+
+    const reWhiteSpace$1 = /^[\S]+( [\S]+)*$/gi;
+    const xpathCache$1 = {};
+    let multiElementReferenceMode = false;
+    let relativeXPathCache = new Map();
+    let modifiedElementAttributes$1 = [];
+    let mutationObserver;
+    const createObserver = (addedNodeCallBack) => {
+        mutationObserver = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation?.addedNodes?.length) {
+                    addedNodeCallBack(mutation?.addedNodes);
+                }
+                if (mutation.target instanceof HTMLElement) {
+                    if (mutation?.type === "attributes" &&
+                        mutation.attributeName === "class" &&
+                        ((isSvg(mutation.target) &&
+                            mutation.oldValue?.trim() ===
+                                mutation.target.classList.value?.trim()) ||
+                            mutation.target.classList?.value
+                                ?.replace(mutation.oldValue, "")
+                                .trim() === "marked-element-temp" ||
+                            mutation?.oldValue
+                                ?.replace(mutation.target.classList?.value, "")
+                                .trim() === "marked-element-temp")) ;
+                    else if (mutation?.type === "attributes" &&
+                        !["flndisabled"].includes(mutation.attributeName)) {
+                        modifiedElementAttributes$1.push({
+                            url: mutation.target.baseURI,
+                            attributeName: mutation.attributeName,
+                            element: mutation.target,
+                            doc: mutation.target.ownerDocument,
+                        });
+                    }
+                }
+            });
+        });
+    };
+    const startObserver = (target, options) => {
+        mutationObserver?.observe(target, options);
+    };
+    const stopObserver = () => {
+        mutationObserver?.disconnect();
+    };
+    const isNumberExist = (str) => {
+        const hasNumber = /\d/;
+        return hasNumber.test(str);
+    };
+    const buildPattern = (pattern, isSvg, tagName) => {
+        return isSvg
+            ? `//*[local-name()='${tagName}' and ${pattern}]`
+            : `//${tagName}[${pattern}]`;
+    };
+    const getTextContent = (targetElement) => {
+        const textContent = targetElement?.textContent;
+        {
+            return textContent;
+        }
+    };
+    const getFilteredText = (element) => {
+        return element?.childNodes[0]?.nodeValue || "";
+    };
+    const getCountOfXPath = (xpath, element, docmt) => {
+        try {
+            let count;
+            // Check if result is cached
+            if (xpathCache$1[xpath] !== undefined) {
+                count = xpathCache$1[xpath];
+            }
+            else {
+                const owner = docmt.nodeType === 9 // DOCUMENT_NODE
+                    ? docmt
+                    : docmt.ownerDocument;
+                count = owner.evaluate(`count(${xpath})`, docmt, null, XPathResult.NUMBER_TYPE, null).numberValue;
+                xpathCache$1[xpath] = count;
+            }
+            if (multiElementReferenceMode && Array.isArray(element)) ;
+            else {
+                // Short-circuit if we only need to match one element
+                if (count === 1) {
+                    const elementFromXpath = getElementFromXpath(xpath, docmt);
+                    return elementFromXpath === element ? count : 0; // Return 0 if no match
+                }
+            }
+            return count; // Return the count
+        }
+        catch (error) {
+            console.error(`Error evaluating XPath: ${xpath}`, error);
+            return 0; // Return 0 on error to avoid re-processing
+        }
+    };
+    const escapeCharacters = (text) => {
+        if (text) {
+            if (!(text.indexOf('"') === -1)) {
+                return `'${text}'`;
+            }
+            if (!(text.indexOf("'") === -1)) {
+                return `"${text}"`;
+            }
+        }
+        return `'${text}'`;
+    };
+    const removeParenthesis = (xpath) => {
+        const charArr = xpath.split("");
+        let count = charArr.length;
+        const indexArray = [];
+        while (charArr[count - 2] !== "[") {
+            indexArray.push(charArr[count - 2]);
+            count--;
+        }
+        indexArray.reverse();
+        let finalStr = "";
+        for (let i = 0; i < indexArray.length; i++) {
+            finalStr += indexArray[i];
+        }
+        const endBracketLength = finalStr.length + 2;
+        let firstpart = xpath.slice(0, xpath.length - endBracketLength);
+        if (firstpart.startsWith("(") && firstpart.endsWith(")")) {
+            firstpart = firstpart.slice(1, -1);
+        }
+        else {
+            firstpart = xpath;
+        }
+        return firstpart;
+    };
+    const findXpathWithIndex = (val, node, docmt, count) => {
+        try {
+            const owner = docmt.nodeType === 9 // DOCUMENT_NODE
+                ? docmt
+                : docmt.ownerDocument;
+            let index = 0;
+            if (count) {
+                if (getCountOfXPath(`${val}[${count}]`, node, docmt) === 1) {
+                    return `${val}[${count}]`;
+                }
+                if (getCountOfXPath(`(${val})[${count}]`, node, docmt) === 1) {
+                    return `(${val})[${count}]`;
+                }
+            }
+            const nodes = owner.evaluate(val, docmt, null, XPathResult.ANY_TYPE, null);
+            let nodex;
+            while ((nodex = nodes.iterateNext())) {
+                index++;
+                if (nodex.isSameNode(node)) {
+                    if (getCountOfXPath(`${val}[${index}]`, node, docmt) === 1) {
+                        return `${val}[${index}]`;
+                    }
+                    if (getCountOfXPath(`(${val})[${index}]`, node, docmt) === 1) {
+                        return `(${val})[${index}]`;
+                    }
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            console.log(error);
+        }
+    };
+    const deleteLineGap = (a) => {
+        a &&= a.split("\n")[0].length > 0 ? a.split("\n")[0] : a.split("\n")[1];
+        return a;
+    };
+    const deleteGarbageFromInnerText = (a) => {
+        a = deleteLineGap(a);
+        a = a
+            .split(/[^\u0000-\u00ff]/)
+            .reduce((b, c) => {
+            return b.length > c.length ? b : c;
+        }, "")
+            .trim();
+        return (a = a.split("/")[0].trim());
+    };
+    const replaceWhiteSpaces = (str) => {
+        if (str) {
+            return str.replace(/\s\s+/g, " ").trim();
+        }
+        return str;
+    };
+    const getShadowRoot = (a) => {
+        for (a = a && a.parentElement; a;) {
+            if (a.toString() === "[object ShadowRoot]")
+                return a;
+            a = a.parentElement;
+        }
+        return null;
+    };
+    const checkBlockedAttributes = (attribute, targetElement, isTarget) => {
+        if (!attribute?.value ||
+            typeof attribute?.value === "boolean" ||
+            ["true", "false", "on", "off", "flntooltip"].some((x) => x === attribute.value) ||
+            ["type", "style", "locator-data-tooltip", "value"].some((x) => x === attribute.name) ||
+            modifiedElementAttributes$1?.find((x) => x.doc === targetElement.ownerDocument &&
+                x.element === targetElement &&
+                x.attributeName === attribute.name) ||
+            (attribute?.name?.indexOf("on") === 0 && attribute?.name?.length > 3) ||
+            typeof attribute.value === "function" ||
+            (isTarget && isNumberExist(attribute.value))) {
+            return false;
+        }
+        return true;
+    };
+    const getRelationship = (a, b) => {
+        let pos = a.compareDocumentPosition(b);
+        return pos === 2
+            ? "preceding"
+            : pos === 4
+                ? "following"
+                : pos === 8
+                    ? "ancestor"
+                    : pos === 16
+                        ? "descendant"
+                        : pos === 32
+                            ? "self"
+                            : "";
+    };
+    const findRoot = (node) => {
+        while (node && node.parentNode) {
+            node = node.parentNode;
+        }
+        return node;
+    };
+    const isSvg = (element) => {
+        return element instanceof SVGElement;
+    };
+    const replaceTempAttributes = (str) => {
+        if (!str)
+            return str;
+        return str.replace(/\b[a-zA-Z_]*disabled\b/gi, "disabled");
+    };
+    const getElementFromXpath = (xpath, docmt, multi = false) => {
+        const owner = docmt.nodeType === 9 // DOCUMENT_NODE
+            ? docmt
+            : docmt.ownerDocument;
+        if (multi) {
+            return owner.evaluate(xpath, docmt, null, XPathResult.ANY_TYPE, null);
+        }
+        else {
+            return owner.evaluate(xpath, docmt, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+        }
+    };
+    const getPropertyXPath = (element, docmt, prop, value, isIndex, isTarget) => {
+        if (value) {
+            const { tagName } = element;
+            let count;
+            let combinePattern = "";
+            const mergePattern = [];
+            let pattern;
+            if (value && (!isTarget || !isNumberExist(value))) {
+                if (!reWhiteSpace$1.test(value)) {
+                    pattern = buildPattern(`normalize-space(${prop})=${escapeCharacters(replaceWhiteSpaces(value)).trim()}`, isSvg(element), element.tagName.toLowerCase());
+                }
+                else {
+                    pattern = `//${tagName}[${prop}=${escapeCharacters(value)}]`;
+                }
+                count = getCountOfXPath(pattern, element, docmt);
+                if (count === 1 && !isIndex) {
+                    return pattern;
+                }
+            }
+            if (value && isTarget) {
+                const splitText = value.split(" ");
+                if (splitText?.length) {
+                    if (splitText.length === 1) {
+                        const contentRes = [...new Set(splitText[0].match(/([^0-9]+)/g))];
+                        if (contentRes?.length >= 1) {
+                            if (contentRes[0] &&
+                                replaceWhiteSpaces(contentRes[0].trim())?.length > 1) {
+                                if (value.startsWith(contentRes[0])) {
+                                    if (!reWhiteSpace$1.test(contentRes[0])) {
+                                        combinePattern = `starts-with(${prop},${escapeCharacters(replaceWhiteSpaces(contentRes[0])).trim()})`;
+                                    }
+                                    else {
+                                        combinePattern = `starts-with(${prop},${escapeCharacters(contentRes[0]).trim()})`;
+                                    }
+                                }
+                            }
+                        }
+                        if (contentRes?.length > 1) {
+                            if (contentRes[contentRes.length - 1] &&
+                                replaceWhiteSpaces(contentRes[contentRes.length - 1].trim())
+                                    ?.length > 1) {
+                                if (value.endsWith(contentRes[contentRes.length - 1])) {
+                                    if (!reWhiteSpace$1.test(contentRes[contentRes.length - 1])) {
+                                        combinePattern = `ends-with(${prop},${escapeCharacters(replaceWhiteSpaces(contentRes[contentRes.length - 1])).trim()})`;
+                                    }
+                                    else {
+                                        combinePattern = `ends-with(${prop},${escapeCharacters(contentRes[contentRes.length - 1]).trim()})`;
+                                    }
+                                }
+                            }
+                        }
+                        if (combinePattern?.length) {
+                            if (isSvg(element)) {
+                                pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                            }
+                            else {
+                                pattern = `//${tagName}[${combinePattern}]`;
+                            }
+                            count = getCountOfXPath(pattern, element, docmt);
+                            if (count === 1 && !isIndex) {
+                                return pattern;
+                            }
+                        }
+                    }
+                    else {
+                        const endIndex = splitText.length % 2 === 0
+                            ? splitText.length / 2
+                            : splitText.length % 2;
+                        const startIndexString = splitText.slice(0, endIndex).join(" ");
+                        let contentRes = [...new Set(startIndexString.match(/([^0-9]+)/g))];
+                        if (contentRes?.length) {
+                            if (contentRes[0] &&
+                                replaceWhiteSpaces(contentRes[0].trim())?.length) {
+                                if (value.startsWith(contentRes[0])) {
+                                    if (!reWhiteSpace$1.test(contentRes[0])) {
+                                        combinePattern = `starts-with(${prop},${escapeCharacters(replaceWhiteSpaces(contentRes[0])).trim()})`;
+                                    }
+                                    else {
+                                        combinePattern = `starts-with(${prop},${escapeCharacters(contentRes[0]).trim()})`;
+                                    }
+                                }
+                            }
+                        }
+                        if (combinePattern?.length) {
+                            if (isSvg(element)) {
+                                pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                            }
+                            else {
+                                pattern = `//${tagName}[${combinePattern}]`;
+                            }
+                            count = getCountOfXPath(pattern, element, docmt);
+                            if (count === 1 && !isIndex) {
+                                return pattern;
+                            }
+                        }
+                        const endIndexString = splitText
+                            .slice(endIndex, splitText.length - 1)
+                            .join(" ");
+                        contentRes = [...new Set(endIndexString.match(/([^0-9]+)/g))];
+                        if (contentRes?.length) {
+                            if (contentRes[0] &&
+                                replaceWhiteSpaces(contentRes[0].trim())?.length > 3) {
+                                if (value.endsWith(contentRes[0])) {
+                                    if (!reWhiteSpace$1.test(contentRes[0])) {
+                                        combinePattern = `ends-with(${prop},${escapeCharacters(replaceWhiteSpaces(contentRes[0])).trim()})`;
+                                    }
+                                    else {
+                                        combinePattern = `ends-with(${prop},${escapeCharacters(contentRes[0]).trim()})`;
+                                    }
+                                }
+                            }
+                        }
+                        if (combinePattern?.length) {
+                            if (isSvg(element)) {
+                                pattern = `//*[local-name()='${tagName}' and ${combinePattern}]`;
+                            }
+                            else {
+                                pattern = `//${tagName}[${combinePattern}]`;
+                            }
+                            count = getCountOfXPath(pattern, element, docmt);
+                            if (count === 1 && !isIndex) {
+                                return pattern;
+                            }
+                        }
+                    }
+                }
+            }
+            if (value && isTarget && isNumberExist(value)) {
+                const contentRes = [...new Set(value.match(/([^0-9]+)/g))];
+                if (contentRes?.length) {
+                    for (let i = 0; i < contentRes?.length; i++) {
+                        if (contentRes[i] &&
+                            replaceWhiteSpaces(contentRes[i].trim())?.length > 1) {
+                            if (!reWhiteSpace$1.test(contentRes[i])) {
+                                mergePattern.push(`contains(${prop},${escapeCharacters(replaceWhiteSpaces(contentRes[i])).trim()})`);
+                            }
+                            else {
+                                mergePattern.push(`contains(${prop},${escapeCharacters(contentRes[i].trim()).trim()})`);
+                            }
+                        }
+                    }
+                }
+                if (mergePattern?.length) {
+                    if (isSvg(element)) {
+                        pattern = `//*[local-name()='${tagName}' and ${mergePattern.join(" and ")}]`;
+                    }
+                    else {
+                        pattern = `//${tagName}[${mergePattern.join(" and ")}]`;
+                    }
+                    count = getCountOfXPath(pattern, element, docmt);
+                    if (count === 1 && !isIndex) {
+                        return pattern;
+                    }
+                }
+            }
+            if (isSvg(element)) {
+                pattern = `//*[local-name()='${tagName}' and text()]`;
+            }
+            else {
+                pattern = `//${tagName}[text()]`;
+            }
+            count = getCountOfXPath(pattern, element, docmt);
+            if (count === 1 && !isIndex) {
+                return pattern;
+            }
+        }
+    };
+    const getAbsoluteXPath = (domNode, docmt) => {
+        try {
+            if (!domNode) {
+                return "";
+            }
+            let xpathe = isSvg(domNode)
+                ? `/*[local-name()='${domNode.tagName}']`
+                : `/${domNode.tagName}`;
+            // // If this node has siblings of the same tagName, get the index of this node
+            if (domNode.parentElement) {
+                // Get the siblings
+                const childNodes = Array.prototype.slice
+                    .call(domNode.parentElement.children, 0)
+                    .filter((childNode) => childNode.tagName === domNode.tagName);
+                //   // If there's more than one sibling, append the index
+                if (childNodes.length > 1) {
+                    const index = childNodes.indexOf(domNode);
+                    xpathe += `[${index + 1}]`;
+                }
+            }
+            else if (domNode instanceof HTMLElement) {
+                if (domNode.offsetParent) {
+                    const childNodes = Array.prototype.slice
+                        .call(domNode.offsetParent.children, 0)
+                        .filter((childNode) => childNode.tagName === domNode.tagName);
+                    //   // If there's more than one sibling, append the index
+                    if (childNodes.length > 1) {
+                        const index = childNodes.indexOf(domNode);
+                        xpathe += `[${index + 1}]`;
+                    }
+                }
+            }
+            // // Make a recursive call to this nodes parents and prepend it to this xpath
+            return getAbsoluteXPath(domNode?.parentElement, docmt) + xpathe;
+        }
+        catch (error) {
+            // If there's an unexpected exception, abort and don't get an XPath
+            console.log("xpath", error);
+            return "";
+        }
+    };
+    const getRelativeXPath = (domNode, docmt, isIndex, isTarget = false, attributesArray) => {
+        try {
+            // Generate a cache key based on the node's identifier, index, and target flag
+            // Check if the result for this node is already cached
+            if (relativeXPathCache.has(domNode)) {
+                return relativeXPathCache.get(domNode);
+            }
+            // Initialize an array to hold parts of the XPath
+            const xpathParts = [];
+            let currentNode = domNode;
+            // Traverse up the DOM tree iteratively instead of using recursion
+            while (currentNode) {
+                let xpathe = "";
+                let hasUniqueAttr = false;
+                let attributes = domNode === currentNode ? attributesArray ?? currentNode.attributes : currentNode.attributes;
+                // Loop through attributes to check for unique identifiers
+                for (const attrName of Array.from(attributes)) {
+                    if (checkBlockedAttributes(attrName, currentNode, isTarget)) {
+                        let attrValue = attrName.nodeValue;
+                        // Clean up attribute value
+                        attrValue = attrValue?.replace("removePointers", "") ?? "";
+                        const elementName = attrName.name;
+                        // Construct an XPath based on attribute
+                        xpathe = getXpathString(currentNode, elementName, attrValue);
+                        let othersWithAttr = 0;
+                        if (xpathe) {
+                            othersWithAttr = getCountOfXPath(xpathe, currentNode, docmt);
+                            if (othersWithAttr === 1) {
+                                xpathParts.unshift(replaceTempAttributes(xpathe));
+                                hasUniqueAttr = true;
+                                break;
+                            }
+                        }
+                        if (othersWithAttr > 1 && isIndex) {
+                            xpathe = findXpathWithIndex(xpathe, currentNode, docmt, othersWithAttr);
+                            if (xpathe) {
+                                xpathParts.unshift(replaceTempAttributes(xpathe));
+                                hasUniqueAttr = true;
+                                break;
+                            }
+                            // return replaceTempAttributes(xpathe);
+                        }
+                    }
+                }
+                if (currentNode.textContent) {
+                    if (!isTarget || (isTarget && !isNumberExist(currentNode.textContent))) {
+                        let reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+                        if (!reWhiteSpace.test(currentNode.textContent)) {
+                            xpathe =
+                                isSvg(currentNode)
+                                    ? `//*[local-name()='${currentNode.tagName}' and normalize-space(.)=${escapeCharacters(getFilteredText(currentNode))}]`
+                                    : `//${currentNode.tagName || "*"}[normalize-space(.)=${escapeCharacters(getFilteredText(currentNode))}]`;
+                        }
+                        else {
+                            xpathe =
+                                isSvg(currentNode)
+                                    ? `//*[local-name()='${currentNode.tagName}' and .=${escapeCharacters(getFilteredText(currentNode))}]`
+                                    : `//${currentNode.tagName || "*"}[.=${escapeCharacters(getFilteredText(currentNode))}]`;
+                        }
+                        let othersWithAttr = getCountOfXPath(xpathe, currentNode, docmt);
+                        if (othersWithAttr === 1) {
+                            return xpathe;
+                        }
+                        if (othersWithAttr > 1 && isIndex) {
+                            xpathe = findXpathWithIndex(xpathe, currentNode, docmt, othersWithAttr);
+                            return xpathe;
+                        }
+                    }
+                    else {
+                        let combinePattern = [];
+                        const contentRes = [
+                            ...new Set(getFilteredText(currentNode).match(/([^0-9]+)/g)),
+                        ];
+                        let reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+                        if (contentRes?.length) {
+                            for (let i = 0; i < contentRes?.length; i++) {
+                                if (contentRes[i] &&
+                                    replaceWhiteSpaces(contentRes[i].trim())) {
+                                    if (!reWhiteSpace.test(contentRes[i])) {
+                                        combinePattern.push(`contains(.,${escapeCharacters(replaceWhiteSpaces(contentRes[i])).trim()})`);
+                                    }
+                                    else {
+                                        combinePattern.push(`contains(.,${escapeCharacters(contentRes[i].trim()).trim()})`);
+                                    }
+                                }
+                            }
+                        }
+                        if (combinePattern?.length) {
+                            xpathe =
+                                isSvg(currentNode)
+                                    ? `//*[local-name()='${currentNode.tagName}' and ${combinePattern.join(" and ")}]`
+                                    : `//${currentNode.tagName || "*"}[${combinePattern.join(" and ")}]`;
+                            let othersWithAttr = getCountOfXPath(xpathe, currentNode, docmt);
+                            if (othersWithAttr === 1) {
+                                return xpathe;
+                            }
+                            if (othersWithAttr > 1 && isIndex) {
+                                xpathe = findXpathWithIndex(xpathe, currentNode, docmt, othersWithAttr);
+                                return xpathe;
+                            }
+                        }
+                    }
+                }
+                // If no unique attribute was found, construct XPath by tag name
+                if (!hasUniqueAttr) {
+                    let tagBasedXPath = isSvg(currentNode)
+                        ? `/*[local-name()='${currentNode.tagName}']`
+                        : `/${currentNode.tagName}`;
+                    // Handle sibling nodes
+                    if (currentNode.parentElement) {
+                        const siblings = Array.from(currentNode.parentElement.children).filter((childNode) => childNode.tagName === currentNode.tagName);
+                        // Append index to distinguish between siblings
+                        if (siblings.length > 1) {
+                            const index = siblings.indexOf(currentNode);
+                            tagBasedXPath += `[${index + 1}]`;
+                        }
+                    }
+                    // Add the constructed tag-based XPath to the parts array
+                    xpathParts.unshift(tagBasedXPath);
+                }
+                else {
+                    break;
+                }
+                // Move up to the parent node for the next iteration
+                currentNode = currentNode.parentElement;
+            }
+            // Combine all parts into the final XPath
+            const finalXPath = `${xpathParts.join("")}`;
+            // Cache the final XPath for this node
+            relativeXPathCache.set(domNode, finalXPath);
+            return finalXPath;
+        }
+        catch (error) {
+            console.log(error);
+            return null;
+        }
+    };
+    const getCombinationXpath = (attribute, domNode) => {
+        const combinePattern = [];
+        let pattern = "";
+        if (attribute &&
+            !isNumberExist(attribute.value) &&
+            typeof attribute.nodeValue !== "function" // &&
+        // !modifiedElementAttributes?.find(
+        //   (x) => x.element === domNode && x.attributeName === attribute.name
+        // )
+        ) {
+            const contentRes = [...new Set(attribute.value.match(/([^0-9]+)/g))];
+            if (contentRes?.length) {
+                for (let i = 0; i < contentRes?.length; i++) {
+                    if (contentRes[i] &&
+                        replaceWhiteSpaces(contentRes[i].trim())?.length > 2) {
+                        if (!reWhiteSpace$1.test(contentRes[i])) {
+                            combinePattern.push(`contains(@${attribute.name},${escapeCharacters(replaceWhiteSpaces(contentRes[i])).trim()})`);
+                        }
+                        else {
+                            combinePattern.push(`contains(@${attribute.name},${escapeCharacters(contentRes[i].trim())})`);
+                        }
+                    }
+                }
+            }
+            if (combinePattern?.length) {
+                pattern = isSvg(domNode)
+                    ? `//*[local-name()='${domNode.tagName}' and ${combinePattern.join(" and ")}]`
+                    : `//${domNode.tagName}[${combinePattern.join(" and ")}]`;
+                return pattern;
+            }
+        }
+    };
+    const getAttributeCombinationXpath = (domNode, docmt, uniqueAttributes, isTarget) => {
+        try {
+            const xpathAttributes = [];
+            if (uniqueAttributes.length > 1) {
+                for (const attrName of uniqueAttributes) {
+                    if (checkBlockedAttributes(attrName, domNode, isTarget)) {
+                        const attrValue = attrName.nodeValue;
+                        if (!reWhiteSpace$1.test(attrValue)) {
+                            xpathAttributes.push(`normalize-space(@${attrName.nodeName})="${attrValue}"`);
+                        }
+                        else if (attrName.nodeName === "class") {
+                            xpathAttributes.push(`contains(@${attrName.nodeName},"${attrValue}")`);
+                        }
+                        else {
+                            xpathAttributes.push(`@${attrName.nodeName}="${attrValue}"`);
+                        }
+                        const xpathe = isSvg(domNode)
+                            ? `//*[local-name()='${domNode.tagName}' and ${xpathAttributes.join(" and ")}]`
+                            : `//${domNode.tagName}[${xpathAttributes.join(" and ")}]`;
+                        let othersWithAttr;
+                        // If the XPath does not parse, move to the next unique attribute
+                        try {
+                            othersWithAttr = getCountOfXPath(xpathe, domNode, docmt);
+                        }
+                        catch (ign) {
+                            continue;
+                        }
+                        if (othersWithAttr === 1 && !xpathe.includes("and")) {
+                            return "";
+                        }
+                        // If the attribute isn't actually unique, get it's index too
+                        if (othersWithAttr === 1 && xpathe.includes("and")) {
+                            return xpathe;
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // If there's an unexpected exception, abort and don't get an XPath
+            console.log(`'${JSON.stringify(error, null, 2)}'`);
+        }
+    };
+    const intermediateXpathStep = (targetElemt, attr, isTarget) => {
+        let isSvgElement = isSvg(targetElemt);
+        let expression = "";
+        if (checkBlockedAttributes(attr, targetElemt, isTarget)) {
+            let attrValue = attr.value;
+            attrValue = attrValue.replace("removePointers", "");
+            const elementName = attr.name;
+            if (!reWhiteSpace$1.test(attrValue)) {
+                expression = isSvgElement
+                    ? `*[local-name()='${targetElemt.tagName}' and normalize-space(@${elementName})=${escapeCharacters(attrValue)}]`
+                    : `${targetElemt.tagName || "*"}[normalize-space(@${elementName})=${escapeCharacters(attrValue)}]`;
+            }
+            else {
+                expression = isSvgElement
+                    ? `*[local-name()='${targetElemt.tagName}' and @${elementName}=${escapeCharacters(attrValue)}]`
+                    : `${targetElemt.tagName || "*"}[@${elementName}=${escapeCharacters(attrValue)}]`;
+            }
+        }
+        return expression;
+    };
+    const getFilteredTextXPath = (node, docmt) => {
+        if (!node.textContent)
+            return "";
+        const filteredText = getFilteredText(node);
+        let xpathe;
+        if (!reWhiteSpace$1.test(filteredText)) {
+            xpathe = isSvg(node)
+                ? `//*[local-name()='${node.tagName}' and normalize-space(.)=${escapeCharacters(filteredText)}]`
+                : `//${node.tagName || "*"}[normalize-space(.)=${escapeCharacters(filteredText)}]`;
+        }
+        else {
+            xpathe = isSvg(node)
+                ? `//*[local-name()='${node.tagName}' and .=${escapeCharacters(filteredText)}]`
+                : `//${node.tagName || "*"}[.=${escapeCharacters(filteredText)}]`;
+        }
+        return xpathe;
+    };
+    const getTextXpathFunction = (domNode) => {
+        const trimmedText = getTextContent(domNode)?.trim();
+        const filteredText = trimmedText
+            ? escapeCharacters(deleteGarbageFromInnerText(trimmedText))
+            : trimmedText;
+        if (filteredText) {
+            if (filteredText !== `'${trimmedText}'`) {
+                return `contains(.,${filteredText})`;
+            }
+            return `normalize-space(.)='${trimmedText}'`;
+        }
+    };
+    const getXpathString = (node, attrName, attrValue) => {
+        const reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+        let xpathe = "";
+        if (attrValue) {
+            if (!reWhiteSpace.test(attrValue)) {
+                xpathe = isSvg(node)
+                    ? `//*[local-name()='${node.tagName}' and contains(@${attrName},${escapeCharacters(attrValue)})]`
+                    : `//${node.tagName || "*"}[contains(@${attrName},${escapeCharacters(attrValue)})]`;
+            }
+            else if (attrName === "class") {
+                xpathe = isSvg(node)
+                    ? `//*[local-name()='${node.tagName}' and contains(@${attrName},${escapeCharacters(attrValue)})]`
+                    : `//${node.tagName || "*"}[contains(@${attrName},${escapeCharacters(attrValue)})]`;
+            }
+            else {
+                xpathe = isSvg(node)
+                    ? `//*[local-name()='${node.tagName}' and @${attrName}=${escapeCharacters(attrValue)}]`
+                    : `//${node.tagName || "*"}[@${attrName}=${escapeCharacters(attrValue)}]`;
+            }
+        }
+        return xpathe;
+    };
+    const replaceActualAttributes = (str, element) => {
+        if (str) {
+            return str.replace(/\bdisabled\b/gi, "flndisabled");
+        }
+        return str;
+    };
+    const addAttributeSplitCombineXpaths = (attributes, targetElemt, docmt, isTarget) => {
+        const attributesArray = Array.prototype.slice.call(attributes);
+        const xpaths = [];
+        try {
+            attributesArray.map((element) => {
+                if (checkBlockedAttributes(element, targetElemt, isTarget)) {
+                    const xpth = getCombinationXpath(element, targetElemt);
+                    if (xpth) {
+                        xpaths.push({
+                            key: `split xpath by ${element.name}`,
+                            value: xpth,
+                        });
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.log(error);
+        }
+        return xpaths;
+    };
+    const getReferenceElementsXpath = (domNode, docmt, isTarget) => {
+        let nodeXpath1;
+        const xpaths1 = [];
+        if (domNode.textContent &&
+            (!isTarget || (isTarget && !isNumberExist(domNode.textContent)))) {
+            if (!reWhiteSpace$1.test(domNode.textContent)) {
+                nodeXpath1 = isSvg(domNode)
+                    ? `*[local-name()='${domNode.tagName}' and ${getTextXpathFunction(domNode)})]`
+                    : `${domNode.tagName}[${getTextXpathFunction(domNode)}]`;
+                if (nodeXpath1) {
+                    xpaths1.push({ key: "getReferenceElementsXpath", value: nodeXpath1 });
+                }
+            }
+            else {
+                nodeXpath1 = isSvg(domNode)
+                    ? `*[local-name()='${domNode.tagName}' and .=${escapeCharacters(getTextContent(domNode))}]`
+                    : `${domNode.tagName}[.=${escapeCharacters(getTextContent(domNode))}]`;
+                if (nodeXpath1) {
+                    xpaths1.push({ key: "getReferenceElementsXpath", value: nodeXpath1 });
+                }
+            }
+        }
+        if (domNode.attributes) {
+            for (const attrName of Array.from(domNode.attributes)) {
+                if (checkBlockedAttributes(attrName, domNode, isTarget)) {
+                    let attrValue = attrName.nodeValue;
+                    if (attrValue) {
+                        attrValue = attrValue.replace("removePointers", "");
+                        const elementName = attrName.name;
+                        if (elementName === "class") {
+                            nodeXpath1 = isSvg(domNode)
+                                ? `*[local-name()='${domNode.tagName}' and contains(@${elementName},${escapeCharacters(attrValue)})]`
+                                : `${domNode.tagName}[contains(@${elementName},${escapeCharacters(attrValue)})]`;
+                        }
+                        else {
+                            nodeXpath1 = isSvg(domNode)
+                                ? `*[local-name()='${domNode.tagName}' and @${elementName}=${escapeCharacters(attrValue)}]`
+                                : `${domNode.tagName}[@${elementName}=${escapeCharacters(attrValue)}]`;
+                        }
+                        if (nodeXpath1) {
+                            xpaths1.push({
+                                key: "getReferenceElementsXpath",
+                                value: nodeXpath1,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        if (!xpaths1?.length) {
+            const attributesArray = Array.prototype.slice.call(domNode.attributes);
+            if (attributesArray?.length > 1) {
+                const combinationXpath = getAttributeCombinationXpath(domNode, docmt, Array.prototype.slice.call(domNode.attributes), isTarget);
+                if (combinationXpath) {
+                    xpaths1.push({
+                        key: "getReferenceElementsXpath",
+                        value: combinationXpath,
+                    });
+                }
+            }
+        }
+        if (!xpaths1?.length) {
+            const combinePattern = [];
+            let pattern;
+            const tag = isSvg(domNode);
+            if (domNode.textContent && isTarget && isNumberExist(domNode.textContent)) {
+                const contentRes = [...new Set(domNode.textContent.match(/([^0-9]+)/g))];
+                if (contentRes?.length) {
+                    for (let i = 0; i < contentRes?.length; i++) {
+                        if (contentRes[i] &&
+                            replaceWhiteSpaces(contentRes[i].trim())?.length > 1) {
+                            if (!reWhiteSpace$1.test(contentRes[i])) {
+                                combinePattern.push(`contains(.,${escapeCharacters(replaceWhiteSpaces(contentRes[i])).trim()})`);
+                            }
+                            else {
+                                combinePattern.push(`contains(.,${escapeCharacters(contentRes[i]).trim()})`);
+                            }
+                        }
+                    }
+                }
+                if (combinePattern?.length) {
+                    if (tag) {
+                        pattern = `//*[local-name()='${tag}' and ${combinePattern.join(" and ")}]`;
+                    }
+                    else {
+                        pattern = `//${tag}[${combinePattern.join(" and ")}]`;
+                    }
+                    if (pattern)
+                        xpaths1.push({ key: "getReferenceElementsXpath", value: pattern });
+                }
+            }
+        }
+        if (!xpaths1?.length) {
+            const xpaths = addAttributeSplitCombineXpaths(domNode.attributes, domNode, docmt, isTarget);
+            if (xpaths?.length) {
+                xpaths1.concat(xpaths);
+            }
+        }
+        return xpaths1;
+    };
+    function parseXml(xmlStr) {
+        if (window.DOMParser) {
+            return new window.DOMParser().parseFromString(xmlStr, "text/xml");
+        }
+        return null;
+    }
+    const normalizeXPath = (xpath) => {
+        // Replace text() = "value"  or  text()='value'
+        xpath = xpath.replace(/text\(\)\s*=\s*(['"])(.*?)\1/g, "normalize-space(.)=$1$2$1");
+        // Replace . = "value" or .='value'
+        xpath = xpath.replace(/\.\s*=\s*(['"])(.*?)\1/g, "normalize-space(.)=$1$2$1");
+        return xpath;
+    };
+    const findMatchingParenthesis = (text, openPos) => {
+        let closePos = openPos;
+        let counter = 1;
+        while (counter > 0) {
+            const c = text[++closePos];
+            if (c == "(") {
+                counter++;
+            }
+            else if (c == ")") {
+                counter--;
+            }
+        }
+        return closePos;
+    };
+    const xpathUtils = {
+        parseXml,
+        getReferenceElementsXpath,
+        getAbsoluteXPath,
+        getRelativeXPath,
+        getCombinationXpath,
+        getAttributeCombinationXpath,
+        getElementFromXpath,
+        isSvg,
+        findXpathWithIndex,
+        isNumberExist,
+        getTextContent,
+        getCountOfXPath,
+        normalizeXPath,
+        getShadowRoot,
+        escapeCharacters,
+        removeParenthesis,
+        checkBlockedAttributes,
+        getRelationship,
+        findMatchingParenthesis,
+        deleteGarbageFromInnerText,
+        replaceTempAttributes,
+        createObserver,
+        startObserver,
+        stopObserver,
+        modifiedElementAttributes: modifiedElementAttributes$1,
+    };
+
+    let xpathData$1 = [];
+    let xpathDataWithIndex$1 = [];
+    let referenceElementMode = false;
+    let xpathCache = new Map();
+    let cache = new Map();
+    const parentXpathCache = new Map(); // Cache for parent XPaths
+    const checkRelativeXpathRelation = (nodeXpath1, nodeXpath2, targetElemt, docmt, isIndex, relationType) => {
+        if (nodeXpath1 && !referenceElementMode) {
+            let xpaths;
+            if (relationType === "parent") {
+                xpaths = [
+                    // `${nodeXpath1}/descendant::${nodeXpath2}`,
+                    `${nodeXpath1}/descendant-or-self::${nodeXpath2}`,
+                    `${nodeXpath1}/following::${nodeXpath2}`,
+                ];
+            }
+            else {
+                xpaths = [
+                    // `${nodeXpath1}/descendant::${nodeXpath2}`,
+                    `${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, 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$1.length) {
+                        if (count < xpathDataWithIndex$1[0].count) {
+                            xpathDataWithIndex$1.pop();
+                            xpathDataWithIndex$1.push({
+                                key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
+                                value: xpath,
+                                count,
+                            });
+                        }
+                    }
+                    else {
+                        xpathDataWithIndex$1.push({
+                            key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
+                            value: xpath,
+                            count,
+                        });
+                    }
+                }
+                if (count > 1 && isIndex && !xpathData$1.length) {
+                    // Try finding XPath with index if count is greater than 1
+                    const indexedXpath = findXpathWithIndex(xpath, targetElemt, docmt, count);
+                    // Cache the indexed XPath result
+                    if (indexedXpath &&
+                        getCountOfXPath(indexedXpath, targetElemt, docmt) === 1) {
+                        xpathData$1.push({
+                            key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
+                            value: indexedXpath,
+                        });
+                    }
+                }
+            }
+        }
+        return null;
+    };
+    const getUniqueParentXpath = (domNode, docmt, node, isTarget, nodeXpath, isIndex) => {
+        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 (checkBlockedAttributes(attrName, currentNode, isTarget)) {
+                        let attrValue = attrName.nodeValue;
+                        attrValue = attrValue?.replace("removePointers", "") ?? "";
+                        const elementName = attrName.name;
+                        const xpathe = 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) {
+                            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 && !isNumberExist(currentNode.textContent))) {
+                        let xpathe;
+                        if (!reWhiteSpace$1.test(currentNode.textContent)) {
+                            xpathe = isSvg(currentNode)
+                                ? `//*[local-name()='${currentNode.tagName}' and normalize-space(.)=${escapeCharacters(getFilteredText(currentNode))}]`
+                                : `//${currentNode.tagName || "*"}[normalize-space(.)=${escapeCharacters(getFilteredText(currentNode))}]`;
+                        }
+                        else {
+                            xpathe = isSvg(currentNode)
+                                ? `//*[local-name()='${currentNode.tagName}' and .=${escapeCharacters(getFilteredText(currentNode))}]`
+                                : `//${currentNode.tagName || "*"}[.=${escapeCharacters(getFilteredText(currentNode))}]`;
+                        }
+                        const othersWithAttr = checkRelativeXpathRelation(xpathe, nodeXpath, node, docmt, isIndex, "parent");
+                        if (othersWithAttr) {
+                            return othersWithAttr;
+                        }
+                    }
+                    else {
+                        const combinePattern = [];
+                        const contentRes = [
+                            ...new Set(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] && replaceWhiteSpaces(contentRes[i].trim())) {
+                                    if (!reWhiteSpace.test(contentRes[i])) {
+                                        combinePattern.push(`contains(.,${escapeCharacters(replaceWhiteSpaces(contentRes[i])).trim()})`);
+                                    }
+                                    else {
+                                        combinePattern.push(`contains(.,${escapeCharacters(contentRes[i].trim()).trim()})`);
+                                    }
+                                }
+                            }
+                        }
+                        if (combinePattern?.length) {
+                            const xpathe = 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 xpathe = isSvg(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("");
+            let count = 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) => {
+        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 (checkBlockedAttributes(attr, currentNode, isTarget)) {
+                        let attrValue = attr.nodeValue;
+                        attrValue = attrValue?.replace("removePointers", "") ?? "";
+                        const elementName = attr.name;
+                        const xpathe = getXpathString(currentNode, elementName, attrValue);
+                        let othersWithAttr;
+                        // If the XPath does not parse, move to the next unique attribute
+                        try {
+                            othersWithAttr = getCountOfXPath(xpathe, currentNode, docmt);
+                        }
+                        catch (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 = getFilteredTextXPath(currentNode, docmt);
+                    if (textXPath) {
+                        const othersWithAttr = getCountOfXPath(textXPath, currentNode, docmt);
+                        if (othersWithAttr === 1) {
+                            uniqueAttrFound = true; // Mark that we found at least one unique attribute
+                            xpathParts.unshift(textXPath);
+                            break;
+                        }
+                    }
+                }
+                if (!uniqueAttrFound) {
+                    // Construct the XPath based on the tag name
+                    const xpathe = 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) {
+            console.log(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 (checkBlockedAttributes(attr, currentNode, true)) {
+                            let attrValue = attr.nodeValue;
+                            attrValue = attrValue?.replace("removePointers", "") ?? "";
+                            const elementName = attr.name;
+                            const xpathe = getXpathString(currentNode, elementName, attrValue);
+                            let othersWithAttr;
+                            // If the XPath does not parse, move to the next unique attribute
+                            try {
+                                othersWithAttr = getCountOfXPath(xpathe, currentNode, docmt);
+                            }
+                            catch (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 = getFilteredTextXPath(currentNode, docmt);
+                        if (textXPath) {
+                            const othersWithAttr = 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 = 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) {
+            console.log(error);
+            return null;
+        }
+    };
+    const getSiblingRelativeXPath = (domNode, docmt, isTarget, nodeXpath) => {
+        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);
+            }
+            for (let n = domNode.previousElementSibling; n !== null && n !== markedSpan; n = n.previousElementSibling) {
+                processSibling(n, domNode, docmt, nodeXpath, "following-sibling", isTarget);
+            }
+        }
+        catch (error) {
+            console.error("sibling error", error);
+            return null;
+        }
+    };
+    const processSibling = (sibling, domNode, docmt, nodeXpath, axis, isTarget) => {
+        try {
+            if (sibling.hasAttributes()) {
+                for (const attr of Array.from(sibling.attributes)) {
+                    let xpathe = intermediateXpathStep(sibling, {
+                        name: attr.name,
+                        value: attr.value,
+                    }, isTarget);
+                    if (xpathe) {
+                        xpathe += `/${axis}::${nodeXpath}`;
+                        const count = getCountOfXPath(xpathe, sibling, docmt);
+                        if (count === 1) {
+                            xpathData$1.push({
+                                key: `xpath by ${axis}`,
+                                value: xpathe,
+                            });
+                            return;
+                        }
+                        else if (count > 1) {
+                            if (xpathDataWithIndex$1.length) {
+                                if (count < xpathDataWithIndex$1[0].count) {
+                                    xpathDataWithIndex$1.pop();
+                                    xpathDataWithIndex$1.push({
+                                        key: `relative xpath by ${axis}`,
+                                        value: xpathe,
+                                        count,
+                                    });
+                                }
+                            }
+                            else {
+                                xpathDataWithIndex$1.push({
+                                    key: `relative xpath by ${axis}`,
+                                    value: xpathe,
+                                    count,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            if (!isTarget) {
+                let xpathe;
+                xpathe = intermediateXpathStep(sibling, {
+                    name: "text",
+                    value: sibling.textContent,
+                }, isTarget);
+                if (xpathe) {
+                    const count = getCountOfXPath(xpathe, sibling, docmt);
+                    if (count === 1) {
+                        xpathData$1.push({
+                            key: `xpath by ${axis}`,
+                            value: xpathe,
+                        });
+                        return;
+                    }
+                    else if (count > 1) {
+                        if (xpathDataWithIndex$1.length) {
+                            if (count < xpathDataWithIndex$1[0].count) {
+                                xpathDataWithIndex$1.pop();
+                                xpathDataWithIndex$1.push({
+                                    key: `relative xpath by ${axis}`,
+                                    value: xpathe,
+                                    count,
+                                });
+                            }
+                        }
+                        else {
+                            xpathDataWithIndex$1.push({
+                                key: `relative xpath by ${axis}`,
+                                value: xpathe,
+                                count,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.log(`${axis} xpath-error`, error);
+        }
+    };
+    function getXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget) {
+        const { tagName } = targetElemt;
+        const textContent = targetElemt.textContent.trim();
+        for (const attrName of attributes) {
+            if (checkBlockedAttributes(attrName, targetElemt, isTarget)) {
+                let attrValue = attrName.nodeValue;
+                attrValue = attrValue?.replace("removePointers", "") ?? "";
+                const elementName = attrName.name;
+                const xpath = `//${tagName}[@${elementName}='${attrValue}' and text()='${textContent}']`;
+                if (xpath) {
+                    const count = getCountOfXPath(xpath, targetElemt, docmt);
+                    if (count == 1) {
+                        return xpath;
+                    }
+                }
+            }
+        }
+    }
+    const addRelativeXpaths = (targetElemt, docmt, isIndex, isTarget, attribute) => {
+        try {
+            let nodeXpath = [];
+            let relativeXpath, relativeChildXpath;
+            if (!xpathData$1.length && isIndex) {
+                if (xpathDataWithIndex$1.length) {
+                    const xpathWithIndex = findXpathWithIndex(xpathDataWithIndex$1[0].value, targetElemt, docmt, xpathDataWithIndex$1[0].count);
+                    if (xpathWithIndex) {
+                        xpathData$1.push({
+                            key: xpathDataWithIndex$1[0].key,
+                            value: xpathWithIndex,
+                        });
+                        xpathDataWithIndex$1.pop();
+                    }
+                }
+            }
+            console.log(attribute);
+            if (!xpathData$1.length) {
+                if (targetElemt.attributes) {
+                    for (const attrName of attribute) {
+                        let expression = intermediateXpathStep(targetElemt, {
+                            name: attrName.name,
+                            value: attrName.value,
+                        }, isTarget);
+                        console.log(expression);
+                        if (expression) {
+                            nodeXpath.push(expression);
+                        }
+                    }
+                }
+                if (targetElemt.textContent) {
+                    let expression = intermediateXpathStep(targetElemt, {
+                        name: "text",
+                        value: targetElemt.textContent,
+                    }, isTarget);
+                    console.log(expression);
+                    if (expression) {
+                        nodeXpath.push(expression);
+                    }
+                }
+                if (nodeXpath?.length) {
+                    for (let i = 0; i < nodeXpath.length; i++) {
+                        if (!xpathData$1.length) {
+                            getSiblingRelativeXPath(targetElemt, docmt, isTarget, nodeXpath[i]);
+                            if (!xpathData$1.length) {
+                                if (!relativeXpath) {
+                                    relativeXpath = getParentRelativeXpath(targetElemt.parentElement, docmt, targetElemt, isTarget);
+                                }
+                                console.log(relativeXpath);
+                                if (relativeXpath &&
+                                    (relativeXpath.includes("@") ||
+                                        relativeXpath.includes("text()") ||
+                                        relativeXpath.includes(".=")) &&
+                                    relativeXpath.match(/\//g)?.length - 2 < 5) {
+                                    const fullRelativeXpath = relativeXpath + `/${nodeXpath[i]}`;
+                                    const count = getCountOfXPath(fullRelativeXpath, targetElemt, docmt);
+                                    if (count === 1) {
+                                        xpathData$1.push({
+                                            key: "relative xpath by relative parent",
+                                            value: fullRelativeXpath,
+                                        });
+                                    }
+                                    else if (count > 1 && isIndex) {
+                                        const relativeXpathIndex = findXpathWithIndex(fullRelativeXpath, targetElemt, docmt, count);
+                                        if (relativeXpathIndex &&
+                                            getCountOfXPath(relativeXpathIndex, targetElemt, docmt) ===
+                                                1) {
+                                            xpathData$1.push({
+                                                key: `relative xpath by relative parent  ${isIndex ? "index" : ""}`,
+                                                value: relativeXpathIndex,
+                                            });
+                                        }
+                                    }
+                                    else if (count > 1) {
+                                        if (xpathDataWithIndex$1.length) {
+                                            if (count < xpathDataWithIndex$1[0].count) {
+                                                xpathDataWithIndex$1.pop();
+                                                xpathDataWithIndex$1.push({
+                                                    key: `relative xpath by relative parent ${isIndex ? "index" : ""}`,
+                                                    value: fullRelativeXpath,
+                                                    count,
+                                                });
+                                            }
+                                        }
+                                        else {
+                                            xpathDataWithIndex$1.push({
+                                                key: `relative xpath by relative parent ${isIndex ? "index" : ""}`,
+                                                value: fullRelativeXpath,
+                                                count,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            if (!xpathData$1.length) {
+                                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 = getCountOfXPath(fullRelativeXpath, targetElemt, docmt);
+                                    if (count === 1) {
+                                        xpathData$1.push({
+                                            key: "relative xpath by relative child",
+                                            value: fullRelativeXpath,
+                                        });
+                                    }
+                                    else if (count > 1 && isIndex) {
+                                        const relativeXpathIndex = findXpathWithIndex(fullRelativeXpath, targetElemt, docmt, count);
+                                        if (relativeXpathIndex &&
+                                            getCountOfXPath(relativeXpathIndex, targetElemt, docmt) ===
+                                                1) {
+                                            xpathData$1.push({
+                                                key: `relative xpath by relative parent  ${isIndex ? "index" : ""}`,
+                                                value: relativeXpathIndex,
+                                            });
+                                        }
+                                    }
+                                    else if (count > 1) {
+                                        if (xpathDataWithIndex$1.length) {
+                                            if (count < xpathDataWithIndex$1[0].count) {
+                                                xpathDataWithIndex$1.pop();
+                                                xpathDataWithIndex$1.push({
+                                                    key: `relative xpath by relative child ${isIndex ? "index" : ""}`,
+                                                    value: fullRelativeXpath,
+                                                    count,
+                                                });
+                                            }
+                                        }
+                                        else {
+                                            xpathDataWithIndex$1.push({
+                                                key: `relative xpath by relative child ${isIndex ? "index" : ""}`,
+                                                value: fullRelativeXpath,
+                                                count,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            if (xpathData$1?.length === 1 &&
+                                xpathData$1?.[0]?.value?.match(/\[([0-9]+)\]/gm)?.length > 3 &&
+                                !referenceElementMode) {
+                                if (targetElemt.textContent) {
+                                    const txtXpath = getTextXPath(targetElemt, docmt, isIndex, false);
+                                    if (txtXpath) {
+                                        xpathData$1.unshift({
+                                            key: `xpath by text${isIndex ? "index" : ""}`,
+                                            value: txtXpath,
+                                        });
+                                    }
+                                }
+                            }
+                            if (!xpathData$1.length) {
+                                let tempRelativeXpath = getUniqueParentXpath(targetElemt.parentElement, docmt, targetElemt, isTarget, nodeXpath[i], isIndex);
+                                if (tempRelativeXpath) {
+                                    xpathData$1.push({
+                                        key: "xpath by unique parent",
+                                        value: tempRelativeXpath,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return xpathData$1;
+        }
+        catch (error) {
+            console.log(error);
+        }
+    };
+    const attributesBasedXPath = (attr, targetElemt, docmt, isIndex, isTarget) => {
+        let attrName;
+        attrName = attr.name;
+        let xpath = getPropertyXPath(targetElemt, docmt, `@${attrName}`, attr.value, isIndex, isTarget);
+        return xpath;
+    };
+    const getUniqueClassName = (element, docmt, isIndex, isTarget) => {
+        let value = element.className;
+        if (typeof value !== "string") {
+            value = "";
+        }
+        value = value?.replace("flndisabled", "disabled");
+        value = value?.replace("removePointers", "");
+        value = value?.trim();
+        if (value) {
+            return getPropertyXPath(element, docmt, `@class`, value, isIndex, isTarget);
+        }
+    };
+    const getTextXPath = (element, docmt, isIndex, isTarget) => {
+        if (element.textContent != "") {
+            const text = getTextContent(element);
+            if (text) {
+                return getPropertyXPath(element, docmt, ".", text, isIndex, isTarget);
+            }
+        }
+    };
+    const addAllXPathAttributes = (attributes, targetElemt, docmt, isIndex, isTarget) => {
+        const attributesArray = attributes;
+        try {
+            attributesArray.map((attr) => {
+                if (!(attr.name === "className" || attr.name === "class")) {
+                    if (checkBlockedAttributes(attr, targetElemt, isTarget)) {
+                        const xpth = attributesBasedXPath(attr, targetElemt, docmt, isIndex, isTarget);
+                        if (xpth) {
+                            xpathData$1.push({
+                                key: `xpath by ${attr.name}${isIndex ? " index" : ""}`,
+                                value: xpth,
+                            });
+                        }
+                    }
+                }
+            });
+            const txtXpath = getTextXPath(targetElemt, docmt, isIndex, isTarget);
+            if (txtXpath) {
+                xpathData$1.push({
+                    key: `xpath by text${isIndex ? " index" : ""}`,
+                    value: txtXpath,
+                });
+            }
+            if (attributesArray.find((element) => element.name === "className") &&
+                checkBlockedAttributes(attributesArray?.find((element) => element.name === "className"), targetElemt, isTarget)) {
+                let xpath = getUniqueClassName(targetElemt, docmt, isIndex, isTarget);
+                if (xpath) {
+                    xpathData$1.push({
+                        key: "xpath by class",
+                        value: xpath,
+                    });
+                }
+            }
+            if (!xpathData$1.length) {
+                const textAttribute = getXPathUsingAttributeAndText(attributes, targetElemt, docmt, isTarget);
+                if (textAttribute)
+                    xpathData$1.push({
+                        key: "xpath by textAttribute",
+                        value: textAttribute,
+                    });
+            }
+            if (!xpathData$1.length && attributesArray.length > 1) {
+                const combinationXpath = getAttributeCombinationXpath(targetElemt, docmt, attributesArray, isTarget);
+                if (combinationXpath)
+                    xpathData$1.push({
+                        key: "xpath by combination",
+                        value: combinationXpath,
+                    });
+            }
+        }
+        catch (error) {
+            console.log(error);
+        }
+    };
+    const parseDOM = (element, doc, isIndex, isTarget) => {
+        xpathData$1 = [];
+        console.log(element);
+        const targetElemt = element;
+        const docmt = targetElemt?.ownerDocument || doc;
+        const tag = targetElemt.tagName;
+        const { attributes } = targetElemt;
+        addAllXPathAttributes(Array.from(attributes), targetElemt, docmt, isIndex, isTarget);
+        {
+            if (xpathData$1.length) {
+                const len = xpathData$1.length;
+                for (let i = 0; i < len; i++) {
+                    let xpth = xpathData$1[i].value;
+                    xpth = xpth.replace(tag, "*");
+                    const count = getCountOfXPath(xpth, element, docmt);
+                    if (count === 1) {
+                        xpathData$1.push({
+                            key: `${xpathData$1[i].key} regex`,
+                            value: xpth,
+                        });
+                    }
+                }
+            }
+        }
+        console.log(xpathData$1);
+        if (!xpathData$1.length) {
+            addRelativeXpaths(targetElemt, docmt, isIndex, isTarget, Array.from(targetElemt.attributes));
+        }
+        return xpathData$1;
+    };
+    const xpath = {
+        parseDOM,
+        getTextXPath,
+        getUniqueClassName,
+        attributesBasedXPath,
+        addAllXPathAttributes,
+        addRelativeXpaths,
+        getXPathUsingAttributeAndText,
+        getSiblingRelativeXPath,
+        getChildRelativeXpath,
+        getParentRelativeXpath,
+        getUniqueParentXpath,
+        checkRelativeXpathRelation,
+    };
+
+    let xpathDataWithIndex = [];
+    let xpathData = [];
+    const reWhiteSpace = /^[\S]+( [\S]+)*$/gi;
+    const findRelativeXpath = (element1, element2, docmt, xpaths1, xpaths2, isIndex) => {
+        // debugger;
+        const par1 = element1.parentElement;
+        const par2 = element2.parentElement;
+        let rel_xpath = [];
+        let tempElement;
+        findRoot(element1);
+        let finalXpaths = [];
+        if (isIndex) {
+            if (xpathDataWithIndex.length) {
+                const xpathWithIndex = findXpathWithIndex(xpathDataWithIndex[0].value, element2, element2.ownerDocument, xpathDataWithIndex[0].count);
+                if (xpathWithIndex) {
+                    finalXpaths = finalXpaths.concat({
+                        key: `${xpathDataWithIndex[0]?.key
+                        ? xpathDataWithIndex[0]?.key
+                        : "xpath with "} index`,
+                        value: xpathWithIndex,
+                    });
+                    xpathDataWithIndex.pop();
+                }
+            }
+        }
+        if (!finalXpaths.length) {
+            // both are same
+            if (element1.isSameNode(element2)) {
+                // rel_xpath = xpath1 + "/self::" + element1.tagName;
+                rel_xpath = getXpathRelationExpression(element1, element2, "self", xpaths1, xpaths2, isIndex);
+                if (rel_xpath)
+                    finalXpaths = finalXpaths.concat(rel_xpath);
+            }
+            // parent
+            tempElement = element1.parentElement;
+            if (tempElement === element2) {
+                rel_xpath = getXpathRelationExpression(element1, element2, "parent", xpaths1, xpaths2, isIndex);
+                if (rel_xpath)
+                    finalXpaths = finalXpaths.concat(rel_xpath);
+            }
+            // ancestor
+            tempElement = element1.parentElement;
+            while (tempElement !== null) {
+                if (tempElement === element2) {
+                    rel_xpath = getXpathRelationExpression(element1, element2, "ancestor", xpaths1, xpaths2, isIndex);
+                    if (rel_xpath) {
+                        finalXpaths = finalXpaths.concat(rel_xpath);
+                        break;
+                    }
+                }
+                tempElement = tempElement.parentNode;
+            }
+            // ancestor-or-self
+            tempElement = element1;
+            do {
+                if (tempElement === element2) {
+                    rel_xpath = getXpathRelationExpression(element1, element2, "ancestor-or-self", xpaths1, xpaths2, isIndex);
+                    if (rel_xpath) {
+                        finalXpaths = finalXpaths.concat(rel_xpath);
+                        break;
+                    }
+                }
+                tempElement = tempElement.parentNode;
+            } while (tempElement !== null);
+            // both has same parent
+            if (par1?.isSameNode(par2)) {
+                for (let m = element1.nextElementSibling; m != null; m = m.nextElementSibling) {
+                    if (m != null && m.isSameNode(element2)) {
+                        rel_xpath = getXpathRelationExpression(element1, element2, "following-sibling", xpaths1, xpaths2, isIndex);
+                        if (rel_xpath) {
+                            finalXpaths = finalXpaths.concat(rel_xpath);
+                            break;
+                        }
+                    }
+                }
+                for (let n = element1.previousElementSibling; n != null; n = n.previousElementSibling) {
+                    if (n != null && n.isSameNode(element2)) {
+                        rel_xpath = getXpathRelationExpression(element1, element2, "preceding-sibling", xpaths1, xpaths2, isIndex);
+                        if (rel_xpath) {
+                            finalXpaths = finalXpaths.concat(rel_xpath);
+                            break;
+                        }
+                    }
+                }
+            }
+            // child
+            if (element1?.children?.length) {
+                for (let m = element1.children[0]; m !== null; m = m?.nextElementSibling) {
+                    if (m === element2) {
+                        rel_xpath = getXpathRelationExpression(element1, element2, "child", xpaths1, xpaths2, isIndex);
+                        if (rel_xpath) {
+                            finalXpaths = finalXpaths.concat(rel_xpath);
+                            break;
+                        }
+                    }
+                }
+            }
+            // following
+            const relation = element1.compareDocumentPosition(element2);
+            if (relation === 2) {
+                rel_xpath = getXpathRelationExpression(element1, element2, "preceding", xpaths1, xpaths2, isIndex);
+            }
+            if (relation === 4) {
+                rel_xpath = getXpathRelationExpression(element1, element2, "following", xpaths1, xpaths2, isIndex);
+            }
+            if (rel_xpath) {
+                finalXpaths = finalXpaths.concat(rel_xpath);
+            }
+            const descendantXpath = getDescendantXpath([element1, element2], docmt, xpaths1, xpaths2, "descendant", isIndex);
+            if (descendantXpath)
+                finalXpaths = finalXpaths.concat(descendantXpath);
+            const descendantSelfXpath = getDescendantXpath([element1, element2], docmt, xpaths1, xpaths2, "descedant-or-self", isIndex);
+            if (descendantSelfXpath) {
+                finalXpaths = finalXpaths.concat(descendantSelfXpath);
+            }
+        }
+        if (finalXpaths.length) {
+            if (finalXpaths.length > 1) {
+                finalXpaths.sort(function (a, b) {
+                    return a.value.length - b.value.length;
+                });
+            }
+            if (finalXpaths.filter((x) => !x.key?.includes("index"))?.length) {
+                return [finalXpaths.filter((x) => !x.key?.includes("index"))[0]];
+            }
+            return [finalXpaths[0]];
+        }
+    };
+    const descendantExpression = (refExpectElement, xpath2, relation, docmt, isIndex, expCommonParentXpathElements, step4, refCommonParentXpathElementLength) => {
+        let finalExpectedElementXpath = "";
+        if (xpath2.split(/\/(?=(?:[^']*\'[^\']*\')*[^\']*$)/g)?.length >=
+            expCommonParentXpathElements.length) {
+            const xpaths2Els = [];
+            const xpath2Elements = xpath2.split(/\/(?=(?:[^']*\'[^\']*\')*[^\']*$)/g);
+            for (let x = 1; x <= expCommonParentXpathElements.length; x++) {
+                xpaths2Els.unshift(x === expCommonParentXpathElements.length
+                    ? expCommonParentXpathElements[expCommonParentXpathElements.length - x]
+                    : xpath2Elements[xpath2Elements.length - x]);
+            }
+            const traverseXpath = getTraverseXpathExpression(`${step4 +
+            (refCommonParentXpathElementLength
+                ? "]".repeat(refCommonParentXpathElementLength)
+                : "")}`, xpaths2Els, refExpectElement[refExpectElement.length - 1], refExpectElement, docmt, relation, isIndex);
+            if (traverseXpath) {
+                return traverseXpath;
+            }
+        }
+        else {
+            finalExpectedElementXpath = `//${step4 +
+            (refCommonParentXpathElementLength
+                ? "]".repeat(refCommonParentXpathElementLength)
+                : "")}/${relation}::${replaceActualAttributes(xpath2, refExpectElement[refExpectElement.length - 1])}`;
+            let rel_count = getCountOfXPath(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt);
+            if (rel_count === 1) {
+                return [
+                    {
+                        key: `dynamic ${relation}`,
+                        value: replaceTempAttributes(finalExpectedElementXpath),
+                    },
+                ];
+            }
+            if (rel_count > 1) {
+                if (isIndex) {
+                    finalExpectedElementXpath = findXpathWithIndex(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt, rel_count);
+                    if (finalExpectedElementXpath) {
+                        rel_count = getCountOfXPath(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt);
+                        if (rel_count === 1) {
+                            return [
+                                {
+                                    key: `dynamic ${relation} ${isIndex ? " index" : ""}`,
+                                    value: replaceTempAttributes(finalExpectedElementXpath),
+                                },
+                            ];
+                        }
+                    }
+                }
+            }
+        }
+    };
+    const getDescendantXpath = (refExpectElement, docmt, xpaths1, xpaths2, relation, isIndex) => {
+        const refElement = refExpectElement[refExpectElement.length - 2];
+        const expElement = refExpectElement[refExpectElement.length - 1];
+        const expElementDocmnt = getShadowRoot(expElement) ?? expElement.ownerDocument;
+        const refAbsoluteXpath = xpaths1.find((x) => x?.key?.includes("absolute"))?.value ||
+            getAbsoluteXPath(refElement, refElement.ownerDocument);
+        const refFullXpathElements = [];
+        const refFullXpathElementsWithoutNumber = [];
+        refAbsoluteXpath.split("/").map((x) => refFullXpathElements.push(x));
+        refFullXpathElements.map((x) => refFullXpathElementsWithoutNumber.push(x.replace(/\[([0-9]+)\]/gm, "")));
+        const expAbsoluteXpath = xpaths2.find((x) => x?.key?.includes("absolute"))?.value ||
+            getAbsoluteXPath(expElement, expElement.ownerDocument);
+        const expFullXpathElements = [];
+        const expFullXpathElementsWithoutNumber = [];
+        expAbsoluteXpath.split("/").map((x) => expFullXpathElements.push(x));
+        expFullXpathElements.map((x) => expFullXpathElementsWithoutNumber.push(x.replace(/\[([0-9]+)\]/gm, "")));
+        for (var parentElementNumber = 0; parentElementNumber < refFullXpathElements.length; parentElementNumber++) {
+            if (refFullXpathElements[parentElementNumber] !=
+                expFullXpathElements[parentElementNumber]) {
+                break;
+            }
+        }
+        const refCommonParentXpathElements = [];
+        for (let i = parentElementNumber - 1; i < refFullXpathElements.length; i++) {
+            if (refFullXpathElements[i]) {
+                refCommonParentXpathElements.push(refFullXpathElementsWithoutNumber[i]);
+            }
+        }
+        const expCommonParentXpathElements = [];
+        for (let j = relation === "descendant" ? parentElementNumber : parentElementNumber - 1; j < expFullXpathElements.length; j++) {
+            if (expFullXpathElements[j]) {
+                if (expCommonParentXpathElements.length)
+                    expCommonParentXpathElements.push(expFullXpathElementsWithoutNumber[j]);
+                else
+                    expCommonParentXpathElements.push(expFullXpathElementsWithoutNumber[j].replace(/\[([0-9]+)\]/gm, ""));
+            }
+        }
+        xpathData = xpaths2;
+        let nodeXpath2;
+        if (refExpectElement[refExpectElement.length - 2].textContent) {
+            if (!reWhiteSpace.test(refExpectElement[refExpectElement.length - 2].textContent)) {
+                nodeXpath2 = isSvg(refExpectElement[refExpectElement.length - 2])
+                    ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName}' and ${getTextXpathFunction(refExpectElement[refExpectElement.length - 2])})]`
+                    : `${refExpectElement[refExpectElement.length - 2].tagName}[${getTextXpathFunction(refExpectElement[refExpectElement.length - 2])}]`;
+            }
+            else {
+                nodeXpath2 = isSvg(refExpectElement[refExpectElement.length - 2])
+                    ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName}' and .=${escapeCharacters(getTextContent(refExpectElement[refExpectElement.length - 2]))}]`
+                    : `${refExpectElement[refExpectElement.length - 2].tagName}[.=${escapeCharacters(getTextContent(refExpectElement[refExpectElement.length - 2]))}]`;
+            }
+            refCommonParentXpathElements[refCommonParentXpathElements.length - 1] =
+                nodeXpath2;
+            const refCommonParentXpath = refCommonParentXpathElements.join("[");
+            const refCommonParentXpathElementLength = refCommonParentXpathElements.length - 1;
+            const step4 = refCommonParentXpath;
+            for (let i = 0; i < xpathData.length; i++) {
+                let xpath2;
+                if (xpathData[i].value.startsWith("//")) {
+                    xpath2 = xpathData[i].value.substring(xpathData[i].value.indexOf("//") + 2);
+                }
+                else {
+                    xpath2 = xpathData[i].value; // No need to modify the value
+                }
+                if (xpath2) {
+                    return descendantExpression(refExpectElement, xpath2, relation, expElementDocmnt || docmt, isIndex, expCommonParentXpathElements, step4, refCommonParentXpathElementLength);
+                }
+            }
+        }
+        if (refExpectElement[refExpectElement.length - 2].attributes) {
+            for (const attrName of Array.from(refExpectElement[refExpectElement.length - 2]
+                .attributes)) {
+                if (checkBlockedAttributes(attrName, refExpectElement[refExpectElement.length - 2], false)) {
+                    let attrValue = attrName.nodeValue;
+                    if (attrValue) {
+                        attrValue = attrValue.replace("removePointers", "");
+                        const elementName = attrName.name;
+                        nodeXpath2 = isSvg(refExpectElement[refExpectElement.length - 2])
+                            ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName}' and @${elementName}=${escapeCharacters(attrValue)}]`
+                            : `${refExpectElement[refExpectElement.length - 2].tagName}[@${elementName}=${escapeCharacters(attrValue)}]`;
+                        refCommonParentXpathElements[refCommonParentXpathElements.length - 1] = nodeXpath2;
+                        const refCommonParentXpath = refCommonParentXpathElements.join("[");
+                        const refCommonParentXpathElementLength = refCommonParentXpathElements.length - 1;
+                        const step4 = refCommonParentXpath;
+                        for (let i = 0; i < xpathData.length; i++) {
+                            let xpath2;
+                            if (xpathData[i].value.startsWith("//")) {
+                                xpath2 = xpathData[i].value.substring(xpathData[i].value.indexOf("//") + 2);
+                            }
+                            else {
+                                xpath2 = xpathData[i].value; // No need to modify the value
+                            }
+                            return descendantExpression(refExpectElement, xpath2, relation, expElementDocmnt || docmt, isIndex, expCommonParentXpathElements, step4, refCommonParentXpathElementLength);
+                        }
+                    }
+                }
+            }
+            for (const attrName of Array.from(refExpectElement[refExpectElement.length - 2]
+                .attributes)) {
+                if (checkBlockedAttributes(attrName, refExpectElement[refExpectElement.length - 2], false)) {
+                    let attrValue = attrName.nodeValue;
+                    if (attrValue) {
+                        attrValue = attrValue.replace("removePointers", "");
+                        const combinationXpath = getCombinationXpath(attrName, refExpectElement[refExpectElement.length - 2]);
+                        if (combinationXpath) {
+                            if (combinationXpath.startsWith("//")) {
+                                nodeXpath2 = combinationXpath.substring(combinationXpath.indexOf("//") + 2);
+                            }
+                            else {
+                                nodeXpath2 = combinationXpath; // No need to modify the value
+                            }
+                            refCommonParentXpathElements[refCommonParentXpathElements.length - 1] = nodeXpath2;
+                            const refCommonParentXpath = refCommonParentXpathElements.join("[");
+                            const refCommonParentXpathElementLength = refCommonParentXpathElements.length - 1;
+                            const step4 = refCommonParentXpath;
+                            for (let i = 0; i < xpathData.length; i++) {
+                                let xpath2;
+                                if (xpathData[i].value.startsWith("//")) {
+                                    xpath2 = xpathData[i].value.substring(xpathData[i].value.indexOf("//") + 2);
+                                }
+                                else {
+                                    xpath2 = xpathData[i].value; // No need to modify the value
+                                }
+                                return descendantExpression(refExpectElement, xpath2, relation, expElementDocmnt || docmt, isIndex, expCommonParentXpathElements, step4, refCommonParentXpathElementLength);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const refCommonParentXpath = refCommonParentXpathElements.join("[");
+        const refCommonParentXpathElementLength = refCommonParentXpathElements.length - 1;
+        const step4 = refCommonParentXpath;
+        const traverseXpath = getTraverseXpathExpression(`${step4 +
+        (refCommonParentXpathElementLength
+            ? "]".repeat(refCommonParentXpathElementLength)
+            : "")}`, expCommonParentXpathElements.reverse(), refExpectElement[refExpectElement.length - 1], refExpectElement, docmt, relation, isIndex);
+        if (traverseXpath) {
+            return traverseXpath;
+        }
+    };
+    const getXpathRelationExpression = (element1, element2, relation, xpath1, xpath2, isIndex) => {
+        let xpaths1;
+        let xpaths2;
+        console.log('getXpathRelationExpression', relation);
+        const finalXpaths = [];
+        try {
+            xpaths1 = xpath1.filter((x) => !x?.key?.includes("absolute"));
+            xpaths2 = xpath2.filter((x) => !x?.key?.includes("absolute"));
+            for (let i = 0; i < xpaths1.length; i++) {
+                for (let j = 0; j < xpaths2.length; j++) {
+                    let rel_xpath = `//${xpaths1[i].value.indexOf("//") !== 0
+                    ? replaceActualAttributes(xpaths1[i].value, element1)
+                    : replaceActualAttributes(xpaths1[i].value.substring(xpaths1[i].value.indexOf("//") + 2), element1)}/${relation}::${xpaths2[j].value.indexOf("//") !== 0
+                    ? replaceActualAttributes(xpaths2[j].value, element2)
+                    : replaceActualAttributes(xpaths2[j].value.substring(xpaths2[j].value.indexOf("//") + 2), element2)}`;
+                    console.log('getXpathRelationExpression', rel_xpath);
+                    const rel_count = getCountOfXPath(rel_xpath, element2, element2.ownerDocument);
+                    if (rel_count > 1) {
+                        if (isIndex) {
+                            rel_xpath = findXpathWithIndex(rel_xpath, element2, element2.ownerDocument, rel_count);
+                            if (rel_xpath) {
+                                finalXpaths.push({
+                                    key: `dynamic ${relation}${isIndex ? " index" : ""}`,
+                                    value: replaceTempAttributes(rel_xpath),
+                                });
+                                return finalXpaths;
+                            }
+                        }
+                        else if (rel_count > 1) {
+                            if (xpathDataWithIndex.length) {
+                                if (rel_count < xpathDataWithIndex[0].count) {
+                                    xpathDataWithIndex.pop();
+                                    xpathDataWithIndex.push({
+                                        key: `relative xpath by relative child ${isIndex ? "index" : ""}`,
+                                        value: rel_xpath,
+                                        count: rel_count,
+                                    });
+                                }
+                            }
+                            else {
+                                xpathDataWithIndex.push({
+                                    key: `relative xpath by relative child ${isIndex ? "index" : ""}`,
+                                    value: rel_xpath,
+                                    count: rel_count,
+                                });
+                            }
+                        }
+                    }
+                    else if (rel_count === 1) {
+                        finalXpaths.push({
+                            key: `dynamic ${relation}`,
+                            value: replaceTempAttributes(rel_xpath),
+                        });
+                        return finalXpaths;
+                    }
+                }
+            }
+            if (!finalXpaths.length) {
+                for (let i = 0; i < xpaths1.length; i++) {
+                    for (let j = 0; j < xpaths2.length; j++) {
+                        const tempPath = `${xpaths2[j].value.indexOf("//") !== 0
+                        ? xpaths2[j].value
+                        : xpaths2[j].value.substring(xpaths2[j].value.indexOf("//") + 2)}`;
+                        const xpath2Elements = tempPath.split(/\/(?=(?:[^']*\'[^\']*\')*[^\']*$)/g);
+                        if (xpath2Elements.length > 1) {
+                            const traverseXpath = getTraverseXpathExpression(`${xpaths1[i].value.indexOf("//") !== 0
+                            ? replaceActualAttributes(xpaths1[i].value, element1)
+                            : replaceActualAttributes(xpaths1[i].value.substring(xpaths1[i].value.indexOf("//") + 2), element1)}`, xpath2Elements, element2, [element1, element2], element2.ownerDocument, relation, isIndex);
+                            console.log('getXpathRelationExpression traverseXpath', traverseXpath);
+                            if (traverseXpath) {
+                                finalXpaths.concat(traverseXpath);
+                                return finalXpaths;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.log(error);
+        }
+        return finalXpaths;
+    };
+    const getReferenceElementXpath = (element) => {
+        let xpaths1 = [];
+        xpaths1 = parseDOM(element, element.ownerDocument, false, false);
+        if (!xpaths1?.length) {
+            xpaths1 = parseDOM(element, element.ownerDocument, true, false);
+            xpaths1 = xpaths1?.map((x) => x.value.charAt(0) == "(" &&
+                findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+                ? { key: "", value: removeParenthesis(x.value) }
+                : { key: "", value: x.value });
+        }
+        else {
+            let xpaths = parseDOM(element, element.ownerDocument, true, false);
+            if (xpaths?.length) {
+                xpaths = xpaths?.map((x) => x.value.charAt(0) == "(" &&
+                    findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+                    ? { key: "", value: removeParenthesis(x.value) }
+                    : { key: "", value: x.value });
+                xpaths1 = xpaths1.concat(xpaths);
+            }
+        }
+        if (!xpaths1?.length) {
+            xpaths1 = [
+                {
+                    key: "",
+                    value: getRelativeXPath(element, element.ownerDocument, false, false, Array.from(element.attributes)),
+                },
+            ];
+        }
+        if (!xpaths1?.length) {
+            xpaths1 = [
+                {
+                    key: "",
+                    value: getRelativeXPath(element, element.ownerDocument, true, false, Array.from(element.attributes)),
+                },
+            ];
+            xpaths1 = xpaths1?.map((x) => x.value.charAt(0) == "(" &&
+                findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+                ? { key: "", value: removeParenthesis(x.value) }
+                : { key: "", value: x.value });
+        }
+        if (!xpaths1?.length) {
+            xpaths1 = getReferenceElementsXpath(element, element.ownerDocument, false);
+        }
+        else {
+            const xpaths = getReferenceElementsXpath(element, element.ownerDocument, false);
+            if (xpaths?.length) {
+                xpaths1 = xpaths1.concat(xpaths);
+            }
+        }
+        const referenceXpathElement = getAbsoluteXPath(element, element.ownerDocument);
+        xpaths1 = xpaths1.filter((x) => x.value !== referenceXpathElement);
+        xpaths1.push({
+            key: "absolute xpath",
+            value: referenceXpathElement.slice(1),
+        });
+        return xpaths1;
+    };
+    const getTraverseXpathExpression = (xpathe1, absoluteXpathElements, element2, refExpectElement, docmt, relation, isIndex) => {
+        let finalExpectedElementXpath;
+        {
+            for (let x = 1; x <= absoluteXpathElements.length; x++) {
+                const xpath2 = absoluteXpathElements
+                    .slice(absoluteXpathElements.length - x, absoluteXpathElements.length)
+                    .join("/");
+                finalExpectedElementXpath = `//${xpathe1}/${relation}::${replaceActualAttributes(xpath2)}`;
+                const rel_count = getCountOfXPath(finalExpectedElementXpath, element2, docmt);
+                if (rel_count === 1) {
+                    return [
+                        {
+                            key: `dynamic ${relation}`,
+                            value: replaceTempAttributes(finalExpectedElementXpath),
+                        },
+                    ];
+                }
+                if (rel_count > 1) {
+                    if (isIndex) {
+                        finalExpectedElementXpath = findXpathWithIndex(finalExpectedElementXpath, refExpectElement[refExpectElement.length - 1], docmt, rel_count);
+                        if (finalExpectedElementXpath) {
+                            return [
+                                {
+                                    key: `dynamic ${relation}${isIndex ? " index" : ""}`,
+                                    value: replaceTempAttributes(finalExpectedElementXpath),
+                                },
+                            ];
+                        }
+                    }
+                }
+            }
+        }
+    };
+    const referenceXpath = {
+        findRelativeXpath,
+        getDescendantXpath,
+        getXpathRelationExpression,
+        getTraverseXpathExpression,
+        getReferenceElementXpath,
+    };
+
+    const getElementFromShadowRoot = (element, selector) => {
+        const shadowRoot = element.shadowRoot;
+        if (shadowRoot && !selector.includes("dynamic")) {
+            return shadowRoot.querySelector(selector);
+        }
+        return null;
+    };
+    const getId = (element) => {
+        return element?.id || null;
+    };
+    const getClassName = (element) => {
+        return element.className || null;
+    };
+    const getVisibleText = (element) => {
+        return element.textContent?.trim() || null;
+    };
+    const getName = (element) => {
+        const elementEl = element;
+        if (elementEl.hasAttribute("name")) {
+            const attrValue = elementEl.getAttribute("name");
+            const name = `${attrValue}`;
+            return name || null;
+        }
+        return null;
+    };
+    const relations = [
+        "/preceding-sibling",
+        "/following-sibling",
+        "/parent",
+        "/descendant",
+        "/ancestor",
+        "/self",
+        "/ancestor-or-self",
+        "/child",
+        "/preceding",
+        "/following",
+    ];
+    function getElementFromXPath(tempDiv, xpath) {
+        let currentElement = tempDiv;
+        const window = currentElement.ownerDocument.defaultView;
+        if (!window)
+            return null;
+        const xpathEvaluator = new window.XPathEvaluator();
+        const xpathResult = xpathEvaluator.evaluate(xpath, currentElement.ownerDocument, //here even tempDiv can be passed
+        null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+        return xpathResult.singleNodeValue;
+    }
+    function checkReferenceElementIsValid(locator, relation, tempDiv) {
+        if (locator.includes(relation)) {
+            const locatotSplitArray = locator.split(relation);
+            const sourceLoc = locatotSplitArray[0].trim();
+            let currentElement = tempDiv;
+            const window = currentElement.ownerDocument.defaultView;
+            if (!window)
+                return null;
+            if (!locator.includes("dynamic")) {
+                const xpathEvaluator = new window.XPathEvaluator();
+                const xpathResult = xpathEvaluator.evaluate(sourceLoc, currentElement.ownerDocument, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+                const sourceElement = xpathResult.singleNodeValue;
+                if (sourceElement) {
+                    const xpathResultComplete = xpathEvaluator.evaluate(locator, currentElement.ownerDocument, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+                    const completeElement = xpathResultComplete.singleNodeValue;
+                    let relativeXpath;
+                    if (completeElement) {
+                        relativeXpath = locator;
+                        return relativeXpath;
+                    }
+                    else {
+                        console.error("Complete Locator is Invalid:", locator);
+                        relativeXpath = locator;
+                        return relativeXpath;
+                    }
+                }
+                else {
+                    console.error("Source Locator Not Found:", sourceLoc);
+                }
+            }
+        }
+        return null;
+    }
+    const getElementsFromHTML = (record, docmt) => {
+        const document = docmt;
+        // global.SVGElement = document.defaultView?.SVGElement!;
+        const tempDiv = document.createElement("div");
+        const elementsToRemove = document.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source, svg");
+        if (elementsToRemove) {
+            elementsToRemove.forEach((tag) => {
+                tag.remove();
+            });
+        }
+        tempDiv.innerHTML = document.body.innerHTML;
+        const finalLocatorsSet = new Set();
+        let finalLocators = [];
+        function createLocator(base, overrides = {}) {
+            const newLocator = {
+                name: overrides.name ?? base?.name,
+                type: overrides.type ?? base?.type,
+                value: overrides.value ?? base?.value,
+                reference: overrides.reference ?? base?.reference,
+                status: overrides.status ?? base?.status,
+                isRecorded: overrides.isRecorded ?? base?.isRecorded,
+            };
+            if (overrides.hasOwnProperty("isSelfHealed")) {
+                newLocator.isSelfHealed = overrides.isSelfHealed;
+            }
+            else if (base?.hasOwnProperty("isSelfHealed")) {
+                newLocator.isSelfHealed = base.isSelfHealed;
+            }
+            pushUniqueLocator(newLocator);
+        }
+        function pushUniqueLocator(obj) {
+            const key = `${obj.name}:${obj.value}`;
+            if (!finalLocatorsSet.has(key)) {
+                finalLocatorsSet.add(key);
+                finalLocators.push(obj);
+            }
+        }
+        /** Locator Value Cleaner (Handles Special Scenarios) **/
+        const cleanLocatorValue = (val, type, isRecorded) => {
+            if (!val)
+                return null;
+            let cleaned = val.trim();
+            // Return null for empty or literal "null"
+            if (!cleaned || cleaned.toLowerCase() === "null")
+                return null;
+            // Unescape any escaped quotes
+            cleaned = cleaned.replace(/\\"/g, '"').replace(/\\'/g, "'");
+            // Remove surrounding single or double quotes
+            cleaned = cleaned.replace(/^['"](.+?)['"]$/, "$1");
+            // Replace double single quotes with a single quote inside XPath
+            cleaned = cleaned.replace(/''/g, "'");
+            // Normalize double quotes in XPath attribute selectors [@id="" -> [@id='']
+            cleaned = cleaned.replace(/\[@(id|name)=['"]{2}(.+?)['"]{2}\]/g, "[@$1='$2']");
+            // For DOM selectors (id or name), remove ALL quotes
+            if (type === "id" || type === "name") {
+                cleaned = cleaned.replace(/['"]/g, "").trim();
+            }
+            if (type === "xpath" && isRecorded === "Y" && !val.startsWith("//"))
+                return null;
+            // Final check for empty strings
+            if (!cleaned || /^['"]{2}$/.test(cleaned))
+                return null;
+            return cleaned;
+        };
+        locators: for (const locator of record.locators) {
+            try {
+                const isRecorded = String(locator.isRecorded || "");
+                const recordedNLocators = record.locators.filter((l) => l.isRecorded === "N");
+                if (recordedNLocators.length > 0) {
+                    for (const locator of recordedNLocators) {
+                        createLocator(locator);
+                    }
+                }
+                const isDynamic = String(locator.value || locator.type || "");
+                if (isDynamic.includes("dynamic") ||
+                    isDynamic.match("dynamic") ||
+                    isDynamic.includes("{") ||
+                    isDynamic.includes("}")) {
+                    createLocator(locator);
+                    continue;
+                }
+                if (record.isShared.includes("Y")) {
+                    break locators;
+                }
+                for (const relation of relations) {
+                    try {
+                        let targetElement = null;
+                        if (locator.value.startsWith("iframe")) {
+                            const iframe = tempDiv.querySelector(locator.value);
+                            if (iframe) {
+                                const iframeDocument = iframe.contentDocument || iframe.contentWindow?.document;
+                                if (iframeDocument) {
+                                    targetElement = iframeDocument.querySelector(locator.value.slice(6));
+                                }
+                            }
+                        }
+                        else {
+                            const selectors = locator.value.split(">>>"); // Custom delimiter for shadow DOM
+                            let currentElement = tempDiv;
+                            for (const selector of selectors) {
+                                if (currentElement) {
+                                    const trimmedSelector = selector.trim();
+                                    if (locator.name.includes("id") ||
+                                        trimmedSelector.startsWith("#")) {
+                                        targetElement = currentElement.querySelector("#" + trimmedSelector);
+                                    }
+                                    else if (locator.name.includes("className") ||
+                                        trimmedSelector.startsWith(".")) {
+                                        targetElement = currentElement.querySelector("." + trimmedSelector);
+                                    }
+                                    else if ((locator.name.includes("xpath") ||
+                                        trimmedSelector.startsWith("//")) &&
+                                        !locator.type.match("dynamic")) {
+                                        if (tempDiv.innerHTML) {
+                                            const normalizedXPath = normalizeXPath(trimmedSelector);
+                                            targetElement = getElementFromXPath(tempDiv, normalizedXPath);
+                                            if (targetElement) {
+                                                createLocator(locator, {
+                                                    value: trimmedSelector,
+                                                    isRecorded: String(locator.isRecorded).includes("N")
+                                                        ? "N"
+                                                        : "Y",
+                                                });
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        targetElement = currentElement.querySelector(trimmedSelector);
+                                        if (!targetElement) {
+                                            targetElement = getElementFromShadowRoot(currentElement, trimmedSelector);
+                                        }
+                                    }
+                                    if (!targetElement &&
+                                        isSvg(currentElement) &&
+                                        !locator.type.match("dynamic")) {
+                                        targetElement = currentElement.querySelector(trimmedSelector);
+                                    }
+                                    currentElement = targetElement;
+                                }
+                                else {
+                                    console.error("Element not found at:", selector);
+                                    break;
+                                }
+                            }
+                        }
+                        const locatorExists = (name, value) => {
+                            const key = `${name}:${value}`;
+                            return finalLocatorsSet.has(key);
+                        };
+                        if (targetElement) {
+                            const idValue = getId(targetElement);
+                            if (idValue && !locatorExists("id", idValue)) {
+                                record.locators.forEach((loc) => {
+                                    createLocator(loc, {
+                                        name: "id",
+                                        value: idValue,
+                                        isRecorded: loc.value === idValue && loc.name === "id"
+                                            ? loc.isRecorded
+                                            : "Y",
+                                        isSelfHealed: loc.value === idValue && loc.name === "id"
+                                            ? loc.isSelfHealed
+                                            : "Y",
+                                    });
+                                });
+                            }
+                            const textValue = getVisibleText(targetElement);
+                            if (textValue) {
+                                record.locators.forEach((loc) => {
+                                    createLocator(loc, {
+                                        name: "linkText",
+                                        type: "static",
+                                        value: textValue,
+                                        isRecorded: loc.value === textValue ? loc.isRecorded : "Y",
+                                        isSelfHealed: loc.value === textValue ? loc.isSelfHealed : "Y",
+                                    });
+                                });
+                            }
+                            const nameLocator = getName(targetElement);
+                            if (nameLocator && !locatorExists("name", nameLocator)) {
+                                record.locators.forEach((loc) => {
+                                    createLocator(loc, {
+                                        name: "name",
+                                        type: "static",
+                                        value: nameLocator,
+                                        isRecorded: loc.value === nameLocator && loc.name === "name"
+                                            ? loc.isRecorded
+                                            : "Y",
+                                        isSelfHealed: loc.value === nameLocator && loc.name === "name"
+                                            ? loc.isSelfHealed
+                                            : "Y",
+                                    });
+                                });
+                            }
+                            const classValue = getClassName(targetElement);
+                            if (classValue &&
+                                classValue.trim() !== "" &&
+                                !locatorExists("className", classValue)) {
+                                record.locators.forEach((loc) => {
+                                    createLocator(loc, {
+                                        name: "className",
+                                        value: classValue,
+                                        isRecorded: loc.value === classValue && loc.name === "className"
+                                            ? loc.isRecorded
+                                            : "Y",
+                                        isSelfHealed: loc.value === classValue && loc.name === "className"
+                                            ? loc.isSelfHealed
+                                            : "Y",
+                                    });
+                                });
+                            }
+                            const fnValue = parseDOM(targetElement, document, false, true);
+                            record.locators.forEach((loc) => {
+                                createLocator(loc, {
+                                    name: 'xpath',
+                                    value: fnValue,
+                                    isRecorded: fnValue?.find((x) => x.value === loc.value)
+                                        ? loc.isRecorded
+                                        : "Y",
+                                    isSelfHealed: fnValue?.find((x) => x.value === loc.value)
+                                        ? loc.isSelfHealed
+                                        : "Y",
+                                });
+                            });
+                            for (const locator of record.locators) {
+                                try {
+                                    for (const loc of record.locators) {
+                                        if (!loc.value)
+                                            continue;
+                                        for (const relation of relations) {
+                                            if (loc.value.includes(relation)) {
+                                                const relativeXpath = checkReferenceElementIsValid(loc.value, relation, tempDiv);
+                                                if (relativeXpath) {
+                                                    createLocator(loc, {
+                                                        name: "xpath",
+                                                        value: relativeXpath,
+                                                        isRecorded: locator.isRecorded !== "" &&
+                                                            locator.isRecorded !== null
+                                                            ? locator.isRecorded
+                                                            : "Y",
+                                                    });
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                catch (error) {
+                                    console.error("Error processing locator:", locator, error);
+                                }
+                            }
+                            const finalAutoHealedLocators = finalLocators.map((obj) => ({
+                                ...obj,
+                                value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded),
+                            }));
+                            const finalUniqueAutoHealedLocators = finalAutoHealedLocators.reduce((unique, locator) => {
+                                if (locator.value &&
+                                    !unique.some((l) => l.value === locator.value)) {
+                                    unique.push(locator);
+                                }
+                                return unique;
+                            }, []);
+                            const jsonResult = [
+                                {
+                                    name: `${record.name}`,
+                                    desc: `${record.desc}`,
+                                    type: `${record.type}`,
+                                    locators: finalUniqueAutoHealedLocators.filter((locator) => locator?.value != null && locator.value !== ""),
+                                    isShared: `${record.isShared}`,
+                                    projectId: `${record.projectId}`,
+                                    projectType: `${record.projectType}`,
+                                    isRecorded: `${record.isRecorded}`,
+                                    folder: `${record.folder}`,
+                                    parentId: `${record.parentId}`,
+                                    parentName: `${record.parentName}`,
+                                    platform: `${record.platform}`,
+                                    licenseId: `${record.licenseId}`,
+                                    licenseType: `${record.licenseType}`,
+                                    userId: `${record.userId}`,
+                                },
+                            ];
+                            return jsonResult;
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error processing locator:", locator, error);
+                        continue;
+                    }
+                }
+            }
+            catch (error) {
+                console.error("Error processing locator:", locator, error);
+                continue;
+            }
+        }
+        return null;
+    };
+
+    let modifiedElementAttributes = [];
+    const parseCssSelectors = (el, docmt) => {
+        let cssSelector = [];
+        try {
+            let idCssSelector = getIdCssPath(el, docmt);
+            if (idCssSelector &&
+                idCssSelector.includes('#') &&
+                docmt.querySelectorAll(idCssSelector)?.length === 1 &&
+                !(idCssSelector.includes('body') ||
+                    idCssSelector.includes('head') ||
+                    idCssSelector.includes('html'))) {
+                cssSelector.push({ key: 'cssSelector by id', value: idCssSelector });
+            }
+            else {
+                idCssSelector = '';
+            }
+            let nameCssSelector = getNameCssPath(el, docmt);
+            if (nameCssSelector &&
+                nameCssSelector !== idCssSelector &&
+                nameCssSelector.includes('name') &&
+                docmt.querySelectorAll(nameCssSelector)?.length === 1 &&
+                !(nameCssSelector.includes('body') ||
+                    nameCssSelector.includes('head') ||
+                    nameCssSelector.includes('html'))) {
+                cssSelector.push({ key: 'cssSelector by name', value: nameCssSelector });
+            }
+            else {
+                nameCssSelector = '';
+            }
+            let classCssSelector = getClassCssPath(el, docmt);
+            if (classCssSelector &&
+                classCssSelector !== idCssSelector &&
+                nameCssSelector !== classCssSelector &&
+                classCssSelector.includes('.') &&
+                docmt.querySelectorAll(classCssSelector)?.length === 1 &&
+                !(classCssSelector.includes('body') ||
+                    classCssSelector.includes('head') ||
+                    classCssSelector.includes('html'))) {
+                cssSelector.push({
+                    key: 'cssSelector by class',
+                    value: classCssSelector,
+                });
+            }
+            else {
+                classCssSelector = '';
+            }
+        }
+        catch (error) {
+            console.log(error);
+        }
+        if (!cssSelector.length) {
+            let abSelector = getAbsoluteCssPath(el, docmt);
+            if (abSelector &&
+                docmt.querySelectorAll(abSelector)?.length === 1 &&
+                !(abSelector.includes('body') ||
+                    abSelector.includes('head') ||
+                    abSelector.includes('html'))) {
+                cssSelector.push({
+                    key: 'Absolute cssSelector',
+                    value: abSelector,
+                });
+            }
+            else {
+                abSelector = '';
+            }
+        }
+        return cssSelector;
+    };
+    const getIdCssPath = (el, docmt) => {
+        const tagName = el.tagName.toLowerCase();
+        if (docmt?.defaultView?.Element &&
+            !(el instanceof docmt?.defaultView?.Element))
+            return;
+        if (tagName.includes('style') || tagName.includes('script'))
+            return;
+        const path = [];
+        while (el.nodeType === Node.ELEMENT_NODE) {
+            let selector = el.nodeName?.toLowerCase();
+            if (el.id && !isNumberExist(el.id)) {
+                selector += `#${el.id}`;
+                path.unshift(selector);
+                break;
+            }
+            else {
+                let sib = el;
+                let nth = 1;
+                if (sib.previousElementSibling) {
+                    while ((sib = sib.previousElementSibling)) {
+                        if (sib.nodeName?.toLowerCase() === selector)
+                            nth++;
+                    }
+                }
+                if (nth !== 1) {
+                    selector += `:nth-of-type(${nth})`;
+                }
+                if (nth === 1 && sib?.parentElement?.childElementCount > 1) {
+                    selector += `:nth-child(${nth})`;
+                }
+            }
+            path.unshift(selector);
+            el = el.parentElement;
+        }
+        return path.join(' > ');
+    };
+    const getNameCssPath = (el, docmt) => {
+        const tagName = el.tagName.toLowerCase();
+        if (docmt?.defaultView?.Element &&
+            !(el instanceof docmt?.defaultView?.Element))
+            return;
+        if (tagName.includes('style') || tagName.includes('script'))
+            return;
+        const path = [];
+        while (el.nodeType === Node.ELEMENT_NODE) {
+            let selector = el.nodeName?.toLowerCase();
+            let name = el.getAttribute('name');
+            if (name && !isNumberExist(name)) {
+                selector += `[name=${name}]`;
+                path.unshift(selector);
+                break;
+            }
+            else {
+                let sib = el;
+                let nth = 1;
+                if (sib.previousElementSibling) {
+                    while ((sib = sib.previousElementSibling)) {
+                        if (sib.nodeName?.toLowerCase() === selector)
+                            nth++;
+                    }
+                }
+                if (nth !== 1) {
+                    selector += `:nth-of-type(${nth})`;
+                }
+                if (nth === 1 && sib?.parentElement?.childElementCount > 1) {
+                    selector += `:nth-child(${nth})`;
+                }
+            }
+            path.unshift(selector);
+            el = el.parentElement;
+        }
+        return path.join(' > ');
+    };
+    const getClassCssPath = (el, docmt) => {
+        const tagName = el.tagName.toLowerCase();
+        if (docmt?.defaultView?.Element &&
+            !(el instanceof docmt?.defaultView?.Element))
+            return;
+        if (tagName.includes('style') || tagName.includes('script'))
+            return;
+        const path = [];
+        while (el.nodeType === Node.ELEMENT_NODE) {
+            let selector = el.nodeName?.toLowerCase();
+            if (typeof el.className === 'string' &&
+                el.className &&
+                !isNumberExist(el.className) &&
+                !modifiedElementAttributes?.find((x) => x.element === el && x.attributeName === 'class')) {
+                el.classList.remove('marked-element-temp');
+                el.classList.remove('removePointers');
+                if (el.className) {
+                    selector += `.${el.className.trim().replace(/\s+/g, '.')}`;
+                    path.unshift(selector);
+                    break;
+                }
+            }
+            else {
+                let sib = el;
+                let nth = 1;
+                if (sib.previousElementSibling) {
+                    while ((sib = sib.previousElementSibling)) {
+                        if (sib.nodeName?.toLowerCase() === selector)
+                            nth++;
+                    }
+                }
+                if (nth !== 1) {
+                    selector += `:nth-of-type(${nth})`;
+                }
+                if (nth === 1 && sib?.parentElement?.childElementCount > 1) {
+                    selector += `:nth-child(${nth})`;
+                }
+            }
+            path.unshift(selector);
+            el = el.parentElement;
+        }
+        return path.join(' > ');
+    };
+    const getAbsoluteCssPath = (el, docmt) => {
+        const tagName = el.tagName.toLowerCase();
+        if (docmt?.defaultView?.Element &&
+            !(el instanceof docmt?.defaultView?.Element))
+            return;
+        if (tagName.includes('style') || tagName.includes('script'))
+            return;
+        const path = [];
+        while (el.nodeType === Node.ELEMENT_NODE) {
+            let selector = el.nodeName?.toLowerCase();
+            if (tagName.includes('body') ||
+                tagName.includes('head') ||
+                tagName.includes('html')) {
+                selector += tagName;
+                path.unshift(selector);
+                break;
+            }
+            else {
+                let sib = el;
+                let nth = 1;
+                if (sib.previousElementSibling) {
+                    while ((sib = sib.previousElementSibling)) {
+                        if (sib.nodeName?.toLowerCase() === selector)
+                            nth++;
+                    }
+                }
+                if (nth !== 1) {
+                    selector += `:nth-of-type(${nth})`;
+                }
+                if (nth === 1 && sib?.parentElement?.childElementCount > 1) {
+                    selector += `:nth-child(${nth})`;
+                }
+            }
+            path.unshift(selector);
+            el = el.parentElement;
+        }
+        return path.join(' > ');
+    };
+    const cssSelectors = {
+        parseCssSelectors,
+        getIdCssPath,
+        getNameCssPath,
+        getClassCssPath,
+        getAbsoluteCssPath
+    };
+
+    const createXPathAPI = () => ({
+        xpath,
+        referenceXpaths: referenceXpath,
+        xpathUtils,
+        getElementsFromHTML,
+        cssSelectors
+    });
+
+    exports.createXPathAPI = createXPathAPI;
+    exports.default = createXPathAPI;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})(this.XpathLib = this.XpathLib || {});