ff-dom 1.0.16 → 1.0.18-beta.1

package/src/utils/xpathHelpers.ts

@@ -0,0 +1,1299 @@
+export const reWhiteSpace = /^[\S]+( [\S]+)*$/gi;
+let cspEnabled: boolean = false;
+const xpathCache: { [x: string]: number } = {};
+let multiElementReferenceMode: boolean = false;
+let relativeXPathCache = new Map();
+export let modifiedElementAttributes: {
+  url: string | null;
+  attributeName: string | null;
+  element: HTMLElement | Element;
+  doc: Document;
+}[] = [];
+let mutationObserver: MutationObserver;
+
+export const createObserver = (addedNodeCallBack: Function) => {
+  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.push({
+            url: mutation.target.baseURI,
+            attributeName: mutation.attributeName,
+            element: mutation.target,
+            doc: mutation.target.ownerDocument,
+          });
+        }
+      }
+    });
+  });
+};
+export const startObserver = (
+  target: Node,
+  options: MutationObserverInit | undefined
+) => {
+  mutationObserver?.observe(target, options);
+};
+
+export const stopObserver = () => {
+  mutationObserver?.disconnect();
+};
+
+export const isNumberExist = (str: string): boolean => {
+  const hasNumber = /\d/;
+  return hasNumber.test(str);
+};
+
+export const buildPattern = (
+  pattern: string,
+  isSvg: boolean,
+  tagName: string
+) => {
+  return isSvg
+    ? `//*[local-name()='${tagName}' and ${pattern}]`
+    : `//${tagName}[${pattern}]`;
+};
+
+export const getTextContent = (
+  targetElement: HTMLElement | Element
+): string => {
+  const textContent = targetElement?.textContent;
+  if (cspEnabled) {
+    if (textContent) {
+      const tooltip = document.querySelector(".flntooltip") as HTMLElement;
+      if (tooltip) {
+        const lastIndex = textContent.lastIndexOf(tooltip.innerText);
+        if (
+          lastIndex &&
+          textContent.length === lastIndex + tooltip.innerText.length
+        ) {
+          return textContent.substring(0, lastIndex);
+        }
+      } else {
+        return textContent;
+      }
+    }
+  } else {
+    return textContent;
+  }
+
+  return "";
+};
+
+export const getFilteredText = (element: Node) => {
+  return element?.childNodes[0]?.nodeValue || "";
+};
+
+export const getCountOfXPath = (
+  xpath: string,
+  element: HTMLElement | Element,
+  docmt: Node
+) => {
+  try {
+    let count;
+    // Check if result is cached
+    if (xpathCache[xpath] !== undefined) {
+      count = xpathCache[xpath];
+    } else {
+      const owner =
+        docmt.nodeType === 9 // DOCUMENT_NODE
+          ? (docmt as Document)
+          : docmt.ownerDocument!;
+
+      count = owner.evaluate(
+        `count(${xpath})`,
+        docmt,
+        null,
+        XPathResult.NUMBER_TYPE,
+        null
+      ).numberValue;
+      xpathCache[xpath] = count;
+    }
+
+    if (multiElementReferenceMode && Array.isArray(element)) {
+      if (count > 1) {
+        const elementsFromXpath = getElementFromXpath(xpath, docmt, true);
+        let nodex,
+          matchedCount = 0;
+        if (elementsFromXpath instanceof XPathResult) {
+          while ((nodex = elementsFromXpath?.iterateNext())) {
+            if (element.includes(nodex)) {
+              matchedCount += 1;
+
+              if (matchedCount === 2) break;
+            }
+          }
+        }
+
+        if (matchedCount !== 2) return 0;
+      }
+    } 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
+  }
+};
+
+export const escapeCharacters = (text: string) => {
+  if (text) {
+    if (!(text.indexOf('"') === -1)) {
+      return `'${text}'`;
+    }
+    if (!(text.indexOf("'") === -1)) {
+      return `"${text}"`;
+    }
+  }
+  return `'${text}'`;
+};
+
+export const removeParenthesis = (xpath: string) => {
+  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;
+};
+
+export const findXpathWithIndex = (
+  val: string,
+  node: HTMLElement | Element,
+  docmt: Node,
+  count: number
+) => {
+  try {
+    const owner =
+      docmt.nodeType === 9 // DOCUMENT_NODE
+        ? (docmt as Document)
+        : 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: string) => {
+  a &&= a.split("\n")[0].length > 0 ? a.split("\n")[0] : a.split("\n")[1];
+  return a;
+};
+
+const deleteGarbageFromInnerText = (a: string) => {
+  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());
+};
+
+export const replaceWhiteSpaces = (str: string) => {
+  if (str) {
+    return str.replace(/\s\s+/g, " ").trim();
+  }
+
+  return str;
+};
+
+export const getShadowRoot = (a: HTMLElement | Element) => {
+  for (a = a && a.parentElement!; a; ) {
+    if (a.toString() === "[object ShadowRoot]") return a;
+    a = a.parentElement!;
+  }
+  return null;
+};
+
+export const checkBlockedAttributes = (
+  attribute: {
+    name: string;
+    value: string;
+  },
+  targetElement: HTMLElement | Element,
+  isTarget: boolean
+) => {
+  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?.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;
+};
+
+export const getRelationship = (a: HTMLElement, b: HTMLElement) => {
+  let pos = a.compareDocumentPosition(b);
+  return pos === 2
+    ? "preceding"
+    : pos === 4
+    ? "following"
+    : pos === 8
+    ? "ancestor"
+    : pos === 16
+    ? "descendant"
+    : pos === 32
+    ? "self"
+    : "";
+};
+
+export const findRoot = (node: Node) => {
+  while (node && node.parentNode) {
+    node = node.parentNode;
+  }
+
+  return node;
+};
+
+export const isSvg = (element: HTMLElement | Element) => {
+  return element instanceof SVGElement;
+};
+
+export const replaceTempAttributes = (str: string): string => {
+  if (!str) return str;
+
+  return str.replace(/\b[a-zA-Z_]*disabled\b/gi, "disabled");
+};
+
+const getElementFromXpath = (xpath: string, docmt: Node, multi = false) => {
+  const owner =
+    docmt.nodeType === 9 // DOCUMENT_NODE
+      ? (docmt as Document)
+      : 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;
+  }
+};
+
+export const getPropertyXPath = (
+  element: HTMLElement | Element,
+  docmt: Document,
+  prop: string,
+  value: string,
+  isIndex: boolean,
+  isTarget: boolean
+) => {
+  if (value) {
+    const { tagName } = element;
+    let count;
+    let combinePattern = "";
+    const mergePattern = [];
+    let pattern;
+
+    if (value && (!isTarget || !isNumberExist(value))) {
+      if (!reWhiteSpace.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.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.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.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.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.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;
+    }
+  }
+};
+
+export const getAbsoluteXPath = (
+  domNode: HTMLElement | Element | null,
+  docmt: Document
+): string => {
+  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: HTMLElement) => 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: HTMLElement) => 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 "";
+  }
+};
+
+export const getRelativeXPath = (
+  domNode: HTMLElement | Element,
+  docmt: Document,
+  isIndex: boolean,
+  isTarget: boolean = false,
+  attributesArray: Attr[]
+) => {
+  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: string | undefined = "";
+      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: number = 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: string[] = [];
+          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] as string).trim())
+              ) {
+                if (!reWhiteSpace.test(contentRes[i] as string)) {
+                  combinePattern.push(
+                    `contains(.,${escapeCharacters(
+                      replaceWhiteSpaces(contentRes[i])
+                    ).trim()})`
+                  );
+                } else {
+                  combinePattern.push(
+                    `contains(.,${escapeCharacters(
+                      (contentRes[i] as string).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;
+  }
+};
+
+export const getCombinationXpath = (
+  attribute: Attr,
+  domNode: HTMLElement | Element
+) => {
+  const combinePattern = [];
+  let pattern: string = "";
+
+  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.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;
+    }
+  }
+};
+
+export const getAttributeCombinationXpath = (
+  domNode: HTMLElement | Element,
+  docmt: Document,
+  uniqueAttributes: Attr[],
+  isTarget: boolean
+) => {
+  try {
+    const xpathAttributes = [];
+
+    if (uniqueAttributes.length > 1) {
+      for (const attrName of uniqueAttributes) {
+        if (checkBlockedAttributes(attrName, domNode, isTarget)) {
+          const attrValue = attrName.nodeValue;
+
+          if (!reWhiteSpace.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)}'`);
+  }
+};
+
+export const intermediateXpathStep = (
+  targetElemt: HTMLElement | Element,
+  attr: { name: string; value: string },
+  isTarget: boolean
+): string => {
+  let isSvgElement = isSvg(targetElemt);
+  let expression: string = "";
+
+  if (checkBlockedAttributes(attr, targetElemt, isTarget)) {
+    let attrValue = attr.value;
+    attrValue = attrValue.replace("removePointers", "");
+    const elementName = attr.name;
+
+    if (!reWhiteSpace.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;
+};
+
+export const getFilteredTextXPath = (
+  node: HTMLElement | Element,
+  docmt: Document
+) => {
+  if (!node.textContent) return "";
+
+  const filteredText = getFilteredText(node);
+
+  let xpathe;
+
+  if (!reWhiteSpace.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;
+};
+
+export const getTextXpathFunction = (domNode: HTMLElement | Element) => {
+  const trimmedText = getTextContent(domNode)?.trim();
+  const filteredText = trimmedText
+    ? escapeCharacters(deleteGarbageFromInnerText(trimmedText))
+    : trimmedText;
+  if (filteredText) {
+    if (filteredText !== `'${trimmedText}'`) {
+      return `contains(.,${filteredText})`;
+    }
+    return `normalize-space(.)='${trimmedText}'`;
+  }
+};
+
+export const getXpathString = (
+  node: HTMLElement | Element,
+  attrName: string,
+  attrValue: string
+) => {
+  const reWhiteSpace = new RegExp(/^[\S]+( [\S]+)*$/gi);
+  let xpathe: string = "";
+
+  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;
+};
+
+export const replaceActualAttributes = (
+  str: string,
+  element: { attributes: any }
+) => {
+  if (str) {
+    return str.replace(/\bdisabled\b/gi, "flndisabled");
+  }
+  return str;
+};
+
+const addAttributeSplitCombineXpaths = (
+  attributes: NamedNodeMap,
+  targetElemt: HTMLElement | Element,
+  docmt: Document,
+  isTarget: boolean
+) => {
+  const attributesArray = Array.prototype.slice.call(attributes);
+  const xpaths: { key: string; value: string }[] = [];
+  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;
+};
+
+export const getReferenceElementsXpath = (
+  domNode: HTMLElement | Element,
+  docmt: Document,
+  isTarget: boolean
+) => {
+  let nodeXpath1;
+  const xpaths1 = [];
+  if (
+    domNode.textContent &&
+    (!isTarget || (isTarget && !isNumberExist(domNode.textContent)))
+  ) {
+    if (!reWhiteSpace.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.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;
+};
+
+export function parseXml(xmlStr: string) {
+  if (window.DOMParser) {
+    return new window.DOMParser().parseFromString(xmlStr, "text/xml");
+  }
+
+  return null;
+}
+
+export const normalizeXPath = (xpath: string): string => {
+  // 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;
+};
+
+export const findMatchingParenthesis = (
+  text: string,
+  openPos: number
+): number => {
+  let closePos = openPos;
+  let counter = 1;
+  while (counter > 0) {
+    const c = text[++closePos];
+    if (c == "(") {
+      counter++;
+    } else if (c == ")") {
+      counter--;
+    }
+  }
+  return closePos;
+};
+
+export 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,
+};