ff-dom 1.0.17 → 1.0.18-beta.2

package/src/utils/xpath.ts

@@ -0,0 +1,1105 @@
+import {
+  isNumberExist,
+  getCountOfXPath,
+  escapeCharacters,
+  checkBlockedAttributes,
+  replaceWhiteSpaces,
+  getTextContent,
+  getPropertyXPath,
+  findXpathWithIndex,
+  getFilteredText,
+  intermediateXpathStep,
+  getAttributeCombinationXpath,
+  getFilteredTextXPath,
+  isSvg,
+  getXpathString,
+  reWhiteSpace,
+  modifiedElementAttributes,
+} from "./xpathHelpers.ts";
+
+let xpathData: { key: string; value: string }[] = [];
+let xpathDataWithIndex: { key: string; value: string; count: number }[] = [];
+let referenceElementMode: boolean = false;
+let xpathCache = new Map();
+let cache = new Map();
+
+const parentXpathCache = new Map(); // Cache for parent XPaths
+
+const checkRelativeXpathRelation = (
+  nodeXpath1: string,
+  nodeXpath2: string,
+  targetElemt: HTMLElement | Element,
+  docmt: Document,
+  isIndex: boolean,
+  relationType: string
+) => {
+  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.length) {
+          if (count < xpathDataWithIndex[0].count) {
+            xpathDataWithIndex.pop();
+            xpathDataWithIndex.push({
+              key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
+              value: xpath,
+              count,
+            });
+          }
+        } else {
+          xpathDataWithIndex.push({
+            key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
+            value: xpath,
+            count,
+          });
+        }
+      }
+
+      if (count > 1 && isIndex && !xpathData.length) {
+        // Try finding XPath with index if count is greater than 1
+        const indexedXpath = findXpathWithIndex(
+          xpath,
+          targetElemt,
+          docmt,
+          count
+        );
+
+        // Cache the indexed XPath result
+        if (
+          indexedXpath &&
+          getCountOfXPath(indexedXpath, targetElemt, docmt) === 1
+        ) {
+          xpathData.push({
+            key: `relative xpath by unique parent ${isIndex ? "index" : ""}`,
+            value: indexedXpath,
+          });
+        }
+      }
+    }
+  }
+  return null;
+};
+
+const getUniqueParentXpath = (
+  domNode: HTMLElement,
+  docmt: Document,
+  node: HTMLElement | Element,
+  isTarget: boolean,
+  nodeXpath: string,
+  isIndex: boolean
+) => {
+  try {
+    if (parentXpathCache.has(domNode)) {
+      return parentXpathCache.get(domNode);
+    }
+
+    // Direct XPath construction without loops
+    const xpathParts = [];
+    let currentNode = domNode;
+
+    while (currentNode && currentNode.nodeType === 1) {
+      const hasUniqueAttr = false;
+      for (const attrName of Array.from(currentNode.attributes)) {
+        if (checkBlockedAttributes(attrName, currentNode, isTarget)) {
+          let attrValue = attrName.nodeValue;
+
+          attrValue = attrValue?.replace("removePointers", "") ?? "";
+          const elementName = attrName.name;
+          const xpathe = getXpathString(currentNode, elementName, attrValue);
+
+          let othersWithAttr;
+
+          // If the XPath does not parse, move to the next unique attribute
+          try {
+            othersWithAttr = checkRelativeXpathRelation(
+              xpathe,
+              nodeXpath,
+              node,
+              docmt,
+              isIndex,
+              "parent"
+            );
+          } catch (ign) {
+            continue;
+          }
+
+          // If the attribute isn't actually unique, get it's index too
+          if (othersWithAttr) {
+            return othersWithAttr;
+          }
+        }
+      }
+
+      if (currentNode.textContent && !currentNode.textContent) {
+        if (
+          !isTarget ||
+          (isTarget && !isNumberExist(currentNode.textContent))
+        ) {
+          let xpathe;
+
+          if (!reWhiteSpace.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);
+      } else {
+        break;
+      }
+
+      // 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: HTMLElement,
+  docmt: Document,
+  node: HTMLElement | Element,
+  isTarget: boolean
+) => {
+  const cache = new Map(); // Cache to store computed results
+
+  if (cache.has(domNode)) {
+    return cache.get(domNode); // Return cached result if available
+  }
+
+  const xpathParts = []; // Initialize an array to hold parts of the XPath
+  let currentNode = domNode; // Start with the provided DOM node
+
+  try {
+    while (currentNode && currentNode.nodeType === 1) {
+      // BASE CASE #1: If this isn't an element, we're above the root, return empty string
+      if (!currentNode.tagName) {
+        return "";
+      }
+
+      // BASE CASE #2: Check for unique attributes
+      let uniqueAttrFound = false;
+      for (const attr of Array.from(currentNode.attributes)) {
+        if (checkBlockedAttributes(attr, currentNode, isTarget)) {
+          let attrValue = attr.nodeValue;
+
+          attrValue = attrValue?.replace("removePointers", "") ?? "";
+          const elementName = attr.name;
+
+          const xpathe = getXpathString(currentNode, elementName, attrValue);
+
+          let othersWithAttr;
+
+          // If the XPath does not parse, move to the next unique attribute
+          try {
+            othersWithAttr = getCountOfXPath(xpathe, currentNode, docmt);
+          } catch (ign) {
+            continue;
+          }
+
+          // If the attribute is unique, return its XPath
+          if (othersWithAttr === 1) {
+            xpathParts.unshift(xpathe);
+            uniqueAttrFound = true; // Mark that we found at least one unique attribute
+            break;
+          }
+        }
+      }
+
+      // If no unique attributes, check for text content
+      if (!uniqueAttrFound && currentNode.textContent && !node.textContent) {
+        const textXPath = getFilteredTextXPath(currentNode, docmt);
+        if (textXPath) {
+          const othersWithAttr = getCountOfXPath(textXPath, currentNode, docmt);
+          if (othersWithAttr === 1) {
+            uniqueAttrFound = true; // Mark that we found at least one unique attribute
+            xpathParts.unshift(textXPath);
+            break;
+          }
+        }
+      }
+
+      if (!uniqueAttrFound) {
+        // Construct the XPath based on the tag name
+        const xpathe = isSvg(currentNode)
+          ? `/*[local-name()='${currentNode.tagName}']`
+          : `/${currentNode.tagName}`;
+
+        // Prepend the current XPath part to the array
+        xpathParts.unshift(xpathe);
+      } else {
+        break;
+      }
+      // Move to the parent node for the next iteration
+      currentNode = currentNode.parentElement!;
+    }
+
+    // Combine all parts into the final XPath
+    const finalXpath = xpathParts.join("");
+    cache.set(domNode, finalXpath); // Store result in cache
+    return finalXpath;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const getChildRelativeXpath = (
+  domNode: HTMLElement | Element,
+  docmt: Document,
+  node: HTMLElement | Element
+) => {
+  const xpathParts = []; // Initialize an array to hold parts of the XPath.
+  let currentNode: HTMLElement | Element | null;
+
+  const st = [];
+  if (
+    domNode.firstElementChild != null &&
+    domNode.firstElementChild.classList.contains("flntooltip")
+  ) {
+    st.unshift(domNode.firstElementChild);
+  } else if (domNode.nextElementSibling != null)
+    st.unshift(domNode.nextElementSibling);
+
+  for (
+    let m = domNode.parentElement;
+    m != null && m.nodeType === 1;
+    m = m.parentElement
+  ) {
+    if (m.nextElementSibling) st.unshift(m.nextElementSibling);
+  }
+
+  try {
+    do {
+      let uniqueAttrFound = false;
+      for (currentNode = st.pop()!; currentNode !== null; ) {
+        for (const attr of Array.from(currentNode.attributes)) {
+          if (checkBlockedAttributes(attr, currentNode, true)) {
+            let attrValue = attr.nodeValue;
+
+            attrValue = attrValue?.replace("removePointers", "") ?? "";
+            const elementName = attr.name;
+
+            const xpathe = getXpathString(currentNode, elementName, attrValue);
+
+            let othersWithAttr;
+
+            // If the XPath does not parse, move to the next unique attribute
+            try {
+              othersWithAttr = getCountOfXPath(xpathe, currentNode, docmt);
+            } catch (ign) {
+              continue;
+            }
+
+            // If the attribute is unique, return its XPath
+            if (othersWithAttr === 1) {
+              uniqueAttrFound = true; // Mark that we found at least one unique attribute
+              xpathParts.push(xpathe);
+              break;
+            }
+          }
+        }
+
+        // If no unique attributes, check for text content
+        if (!uniqueAttrFound && currentNode.textContent && !node.textContent) {
+          const textXPath = getFilteredTextXPath(currentNode, docmt);
+          if (textXPath) {
+            const othersWithAttr = getCountOfXPath(
+              textXPath,
+              currentNode,
+              docmt
+            );
+            if (othersWithAttr === 1) {
+              uniqueAttrFound = true; // Mark that we found at least one unique attribute
+              xpathParts.push(textXPath);
+              break;
+            }
+          }
+        }
+
+        if (!uniqueAttrFound) {
+          // Construct the XPath based on the tag name
+          const xpathe = isSvg(currentNode)
+            ? `/*[local-name()='${currentNode.tagName}']`
+            : `/${currentNode.tagName}`;
+
+          // Prepend the current XPath part to the array
+          xpathParts.push(xpathe);
+
+          if (currentNode.firstElementChild != null) {
+            st.push(currentNode.nextElementSibling);
+            currentNode = currentNode.firstElementChild;
+          } else {
+            currentNode = currentNode.nextElementSibling;
+          }
+        } else {
+          break;
+        }
+      }
+    } while (st.length > 0);
+
+    // Combine all parts into the final XPath
+    const finalXpath = xpathParts.join("");
+    cache.set(domNode, finalXpath); // Store result in cache
+    return finalXpath;
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const getSiblingRelativeXPath = (
+  domNode: HTMLElement | Element,
+  docmt: Document,
+  isTarget: boolean,
+  nodeXpath: string
+) => {
+  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: Element,
+  domNode: HTMLElement | Element,
+  docmt: Document,
+  nodeXpath: string,
+  axis: string,
+  isTarget: boolean
+) => {
+  try {
+    if (sibling.hasAttributes()) {
+      for (const attr of Array.from(sibling.attributes)) {
+        let xpathe = intermediateXpathStep(
+          sibling,
+          {
+            name: attr.name,
+            value: attr.value,
+          },
+          isTarget
+        );
+        if (xpathe) {
+          xpathe += `/${axis}::${nodeXpath}`;
+
+          const count = getCountOfXPath(xpathe, sibling, docmt);
+
+          if (count === 1) {
+            xpathData.push({
+              key: `xpath by ${axis}`,
+              value: xpathe,
+            });
+            return;
+          } else if (count > 1) {
+            if (xpathDataWithIndex.length) {
+              if (count < xpathDataWithIndex[0].count) {
+                xpathDataWithIndex.pop();
+                xpathDataWithIndex.push({
+                  key: `relative xpath by ${axis}`,
+                  value: xpathe,
+                  count,
+                });
+              }
+            } else {
+              xpathDataWithIndex.push({
+                key: `relative xpath by ${axis}`,
+                value: xpathe,
+                count,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    if (!isTarget) {
+      let xpathe;
+      xpathe = intermediateXpathStep(
+        sibling,
+        {
+          name: "text",
+          value: sibling.textContent,
+        },
+        isTarget
+      );
+
+      if (xpathe) {
+        const count = getCountOfXPath(xpathe, sibling, docmt);
+
+        if (count === 1) {
+          xpathData.push({
+            key: `xpath by ${axis}`,
+            value: xpathe,
+          });
+          return;
+        } else if (count > 1) {
+          if (xpathDataWithIndex.length) {
+            if (count < xpathDataWithIndex[0].count) {
+              xpathDataWithIndex.pop();
+              xpathDataWithIndex.push({
+                key: `relative xpath by ${axis}`,
+                value: xpathe,
+                count,
+              });
+            }
+          } else {
+            xpathDataWithIndex.push({
+              key: `relative xpath by ${axis}`,
+              value: xpathe,
+              count,
+            });
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.log(`${axis} xpath-error`, error);
+  }
+};
+
+function getXPathUsingAttributeAndText(
+  attributes: Attr[],
+  targetElemt: HTMLElement | Element,
+  docmt: Document,
+  isTarget: boolean
+) {
+  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: HTMLElement | Element,
+  docmt: Document,
+  isIndex: boolean,
+  isTarget: boolean,
+  attribute: Attr[]
+) => {
+  try {
+    let nodeXpath: string[] = [];
+    let relativeXpath, relativeChildXpath;
+
+    if (!xpathData.length && isIndex) {
+      if (xpathDataWithIndex.length) {
+        const xpathWithIndex = findXpathWithIndex(
+          xpathDataWithIndex[0].value,
+          targetElemt,
+          docmt,
+          xpathDataWithIndex[0].count
+        );
+        if (xpathWithIndex) {
+          xpathData.push({
+            key: xpathDataWithIndex[0].key,
+            value: xpathWithIndex,
+          });
+          xpathDataWithIndex.pop();
+        }
+      }
+    }
+
+    console.log(attribute);
+    if (!xpathData.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.length) {
+            getSiblingRelativeXPath(targetElemt, docmt, isTarget, nodeXpath[i]);
+
+            if (!xpathData.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.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.push({
+                      key: `relative xpath by relative parent  ${
+                        isIndex ? "index" : ""
+                      }`,
+                      value: relativeXpathIndex,
+                    });
+                  }
+                } else if (count > 1) {
+                  if (xpathDataWithIndex.length) {
+                    if (count < xpathDataWithIndex[0].count) {
+                      xpathDataWithIndex.pop();
+                      xpathDataWithIndex.push({
+                        key: `relative xpath by relative parent ${
+                          isIndex ? "index" : ""
+                        }`,
+                        value: fullRelativeXpath,
+                        count,
+                      });
+                    }
+                  } else {
+                    xpathDataWithIndex.push({
+                      key: `relative xpath by relative parent ${
+                        isIndex ? "index" : ""
+                      }`,
+                      value: fullRelativeXpath,
+                      count,
+                    });
+                  }
+                }
+              }
+            }
+
+            if (!xpathData.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.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.push({
+                      key: `relative xpath by relative parent  ${
+                        isIndex ? "index" : ""
+                      }`,
+                      value: relativeXpathIndex,
+                    });
+                  }
+                } else if (count > 1) {
+                  if (xpathDataWithIndex.length) {
+                    if (count < xpathDataWithIndex[0].count) {
+                      xpathDataWithIndex.pop();
+                      xpathDataWithIndex.push({
+                        key: `relative xpath by relative child ${
+                          isIndex ? "index" : ""
+                        }`,
+                        value: fullRelativeXpath,
+                        count,
+                      });
+                    }
+                  } else {
+                    xpathDataWithIndex.push({
+                      key: `relative xpath by relative child ${
+                        isIndex ? "index" : ""
+                      }`,
+                      value: fullRelativeXpath,
+                      count,
+                    });
+                  }
+                }
+              }
+            }
+
+            if (
+              xpathData?.length === 1 &&
+              xpathData?.[0]?.value?.match(/\[([0-9]+)\]/gm)?.length! > 3 &&
+              !referenceElementMode
+            ) {
+              if (targetElemt.textContent) {
+                const txtXpath = getTextXPath(
+                  targetElemt,
+                  docmt,
+                  isIndex,
+                  false
+                );
+                if (txtXpath) {
+                  xpathData.unshift({
+                    key: `xpath by text${isIndex ? "index" : ""}`,
+                    value: txtXpath,
+                  });
+                }
+              }
+            }
+
+            if (!xpathData.length) {
+              let tempRelativeXpath = getUniqueParentXpath(
+                targetElemt.parentElement!,
+                docmt,
+                targetElemt,
+                isTarget,
+                nodeXpath[i],
+                isIndex
+              );
+
+              if (tempRelativeXpath) {
+                xpathData.push({
+                  key: "xpath by unique parent",
+                  value: tempRelativeXpath,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return xpathData;
+  } catch (error) {
+    console.log(error);
+  }
+};
+
+export const attributesBasedXPath = (
+  attr: Attr,
+  targetElemt: HTMLElement | Element,
+  docmt: Document,
+  isIndex: boolean,
+  isTarget: boolean
+) => {
+  let attrName;
+
+  attrName = attr.name;
+  let xpath = getPropertyXPath(
+    targetElemt,
+    docmt,
+    `@${attrName}`,
+    attr.value,
+    isIndex,
+    isTarget
+  );
+
+  return xpath;
+};
+
+export const getUniqueClassName = (
+  element: HTMLElement | Element,
+  docmt: Document,
+  isIndex: boolean,
+  isTarget: boolean
+) => {
+  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);
+  }
+};
+
+export const getTextXPath = (
+  element: HTMLElement | Element,
+  docmt: Document,
+  isIndex: boolean,
+  isTarget: boolean
+) => {
+  if (element.textContent != "") {
+    const text = getTextContent(element);
+
+    if (text) {
+      return getPropertyXPath(element, docmt, ".", text, isIndex, isTarget);
+    }
+  }
+};
+
+const addAllXPathAttributes = (
+  attributes: Attr[],
+  targetElemt: HTMLElement | Element,
+  docmt: Document,
+  isIndex: boolean,
+  isTarget: boolean
+) => {
+  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.push({
+              key: `xpath by ${attr.name}${isIndex ? " index" : ""}`,
+              value: xpth,
+            });
+          }
+        }
+      }
+    });
+
+    const txtXpath = getTextXPath(targetElemt, docmt, isIndex, isTarget);
+    if (txtXpath) {
+      xpathData.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.push({
+          key: "xpath by class",
+          value: xpath,
+        });
+      }
+    }
+
+    if (!xpathData.length) {
+      const textAttribute = getXPathUsingAttributeAndText(
+        attributes,
+        targetElemt,
+        docmt,
+        isTarget
+      );
+      if (textAttribute)
+        xpathData.push({
+          key: "xpath by textAttribute",
+          value: textAttribute,
+        });
+    }
+
+    if (!xpathData.length && attributesArray.length > 1) {
+      const combinationXpath = getAttributeCombinationXpath(
+        targetElemt,
+        docmt,
+        attributesArray,
+        isTarget
+      );
+      if (combinationXpath)
+        xpathData.push({
+          key: "xpath by combination",
+          value: combinationXpath,
+        });
+    }
+  } catch (error) {
+    console.log(error);
+  }
+};
+
+export const parseDOM = (
+  element: HTMLElement | Element,
+  doc: Document,
+  isIndex: boolean,
+  isTarget: boolean
+) => {
+  xpathData = [];
+  console.log(element);
+  const targetElemt = element;
+  const docmt = targetElemt?.ownerDocument || doc;
+  const tag = targetElemt.tagName;
+  const { attributes } = targetElemt;
+  addAllXPathAttributes(Array.from(attributes), targetElemt, docmt, isIndex, isTarget);
+  if (!referenceElementMode) {
+    if (xpathData.length) {
+      const len = xpathData.length;
+      for (let i = 0; i < len; i++) {
+        let xpth = xpathData[i].value;
+        xpth = xpth.replace(tag, "*");
+        const count = getCountOfXPath(xpth, element, docmt);
+        if (count === 1) {
+          xpathData.push({
+            key: `${xpathData[i].key} regex`,
+            value: xpth,
+          });
+        }
+      }
+    }
+  }
+
+  console.log(xpathData);
+  if (!xpathData.length) {
+    addRelativeXpaths(
+      targetElemt,
+      docmt,
+      isIndex,
+      isTarget,
+      Array.from(targetElemt.attributes)
+    );
+  }
+
+  return xpathData;
+};
+
+const xpath = {
+  parseDOM,
+  getTextXPath,
+  getUniqueClassName,
+  attributesBasedXPath,
+  addAllXPathAttributes,
+  addRelativeXpaths,
+  getXPathUsingAttributeAndText,
+  getSiblingRelativeXPath,
+  getChildRelativeXpath,
+  getParentRelativeXpath,
+  getUniqueParentXpath,
+  checkRelativeXpathRelation,
+};
+
+export default xpath;