ff-dom 1.0.17 → 1.0.18-beta.1

package/dist/index.browser.cjs

@@ -0,0 +1,2773 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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;
+            // Loop through attributes to check for unique identifiers
+            for (const attrName of 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 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 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 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 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 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([...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, [...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 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 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, [...element.attributes]),
+            },
+        ];
+    }
+    if (!xpaths1?.length) {
+        xpaths1 = [
+            {
+                key: "",
+                value: getRelativeXPath(element, element.ownerDocument, true, false, [...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;
+//# sourceMappingURL=index.browser.cjs.map