ff-dom 1.0.17 → 1.0.18-beta.2

package/src/utils/referenceXpath.ts

@@ -0,0 +1,936 @@
+import { parseDOM } from "./xpath.ts";
+import {
+  findXpathWithIndex,
+  findRoot,
+  getShadowRoot,
+  getTextContent,
+  escapeCharacters,
+  getCountOfXPath,
+  checkBlockedAttributes,
+  isNumberExist,
+  getAbsoluteXPath,
+  isSvg,
+  getCombinationXpath,
+  getTextXpathFunction,
+  replaceTempAttributes,
+  replaceActualAttributes,
+  getReferenceElementsXpath,
+  getRelativeXPath,
+  findMatchingParenthesis,
+  removeParenthesis,
+  modifiedElementAttributes
+} from "./xpathHelpers.ts";
+
+let xpathDataWithIndex: any[] = [];
+let xpathData: { key: string; value: string }[] = [];
+const reWhiteSpace = /^[\S]+( [\S]+)*$/gi;
+let multiElementReferenceMode: boolean = false;
+
+export const findRelativeXpath = (
+  element1: HTMLElement | Element,
+  element2: HTMLElement | Element,
+  docmt: Document,
+  xpaths1: any[],
+  xpaths2: any[],
+  isIndex: any
+) => {
+  // debugger;
+  const par1 = element1.parentElement;
+  const par2 = element2.parentElement;
+  let rel_xpath: any[] = [];
+
+  let tempElement;
+  const root = findRoot(element1);
+  let finalXpaths: any[] = [];
+
+  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: Array<HTMLElement | Element>,
+  xpath2: string,
+  relation: string,
+  docmt: Node,
+  isIndex: any,
+  expCommonParentXpathElements: string | any[],
+  step4: string,
+  refCommonParentXpathElementLength: number
+) => {
+  let finalExpectedElementXpath: string | undefined = "";
+
+  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: Array<HTMLElement | Element>,
+  docmt: Document,
+  xpaths1: { key: string; value: string }[],
+  xpaths2: { key: string; value: string }[],
+  relation: "descendant" | "descedant-or-self",
+  isIndex: boolean
+) => {
+  const refElement: HTMLElement | Element = refExpectElement[refExpectElement.length - 2];
+  const expElement: HTMLElement | Element = 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: any[] = [];
+  const refFullXpathElementsWithoutNumber: any[] = [];
+  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: any[] = [];
+  const expFullXpathElementsWithoutNumber: any[] = [];
+  expAbsoluteXpath.split("/").map((x) => expFullXpathElements.push(x));
+  expFullXpathElements.map((x) =>
+    expFullXpathElementsWithoutNumber.push(x.replace(/\[([0-9]+)\]/gm, ""))
+  );
+
+  for (
+    var parentElementNumber = 0;
+    parentElementNumber < refFullXpathElements.length;
+    parentElementNumber++
+  ) {
+    if (
+      refFullXpathElements[parentElementNumber] !=
+      expFullXpathElements[parentElementNumber]
+    ) {
+      break;
+    }
+  }
+
+  const refCommonParentXpathElements = [];
+  for (let i = parentElementNumber - 1; i < refFullXpathElements.length; i++) {
+    if (refFullXpathElements[i]) {
+      refCommonParentXpathElements.push(refFullXpathElementsWithoutNumber[i]);
+    }
+  }
+
+  const expCommonParentXpathElements = [];
+  for (
+    let j =
+      relation === "descendant" ? parentElementNumber : parentElementNumber - 1;
+    j < expFullXpathElements.length;
+    j++
+  ) {
+    if (expFullXpathElements[j]) {
+      if (expCommonParentXpathElements.length)
+        expCommonParentXpathElements.push(expFullXpathElementsWithoutNumber[j]);
+      else
+        expCommonParentXpathElements.push(
+          expFullXpathElementsWithoutNumber[j].replace(/\[([0-9]+)\]/gm, "")
+        );
+    }
+  }
+
+  xpathData = xpaths2;
+
+  let nodeXpath2;
+  if (refExpectElement[refExpectElement.length - 2].textContent) {
+    if (
+      !reWhiteSpace.test(
+        refExpectElement[refExpectElement.length - 2].textContent
+      )
+    ) {
+      nodeXpath2 = isSvg(refExpectElement[refExpectElement.length - 2])
+        ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName
+        }' and ${getTextXpathFunction(
+          refExpectElement[refExpectElement.length - 2]
+        )})]`
+        : `${refExpectElement[refExpectElement.length - 2].tagName
+        }[${getTextXpathFunction(
+          refExpectElement[refExpectElement.length - 2]
+        )}]`;
+    } else {
+      nodeXpath2 = isSvg(refExpectElement[refExpectElement.length - 2])
+        ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName
+        }' and .=${escapeCharacters(
+          getTextContent(refExpectElement[refExpectElement.length - 2])
+        )}]`
+        : `${refExpectElement[refExpectElement.length - 2].tagName
+        }[.=${escapeCharacters(
+          getTextContent(refExpectElement[refExpectElement.length - 2])
+        )}]`;
+    }
+
+    refCommonParentXpathElements[refCommonParentXpathElements.length - 1] =
+      nodeXpath2;
+
+    const refCommonParentXpath = refCommonParentXpathElements.join("[");
+    const refCommonParentXpathElementLength =
+      refCommonParentXpathElements.length - 1;
+
+    const step4 = refCommonParentXpath;
+
+    for (let i = 0; i < xpathData.length; i++) {
+      let xpath2;
+
+      if (xpathData[i].value.startsWith("//")) {
+        xpath2 = xpathData[i].value.substring(
+          xpathData[i].value.indexOf("//") + 2
+        );
+      } else {
+        xpath2 = xpathData[i].value; // No need to modify the value
+      }
+      if (xpath2) {
+        return descendantExpression(
+          refExpectElement,
+          xpath2,
+          relation,
+          expElementDocmnt || docmt,
+          isIndex,
+          expCommonParentXpathElements,
+          step4,
+          refCommonParentXpathElementLength
+        );
+      }
+    }
+  }
+
+  if (refExpectElement[refExpectElement.length - 2].attributes) {
+    for (const attrName of Array.from(refExpectElement[refExpectElement.length - 2]
+      .attributes)) {
+      if (
+        checkBlockedAttributes(attrName, refExpectElement[refExpectElement.length - 2], false)
+      ) {
+        let attrValue = attrName.nodeValue;
+        if (attrValue) {
+          attrValue = attrValue.replace("removePointers", "");
+          const elementName = attrName.name;
+
+          nodeXpath2 = isSvg(refExpectElement[refExpectElement.length - 2])
+            ? `*[local-name()='${refExpectElement[refExpectElement.length - 2].tagName
+            }' and @${elementName}=${escapeCharacters(attrValue)}]`
+            : `${refExpectElement[refExpectElement.length - 2].tagName
+            }[@${elementName}=${escapeCharacters(attrValue)}]`;
+
+          refCommonParentXpathElements[
+            refCommonParentXpathElements.length - 1
+          ] = nodeXpath2;
+
+          const refCommonParentXpath = refCommonParentXpathElements.join("[");
+          const refCommonParentXpathElementLength =
+            refCommonParentXpathElements.length - 1;
+
+          const step4 = refCommonParentXpath;
+
+          for (let i = 0; i < xpathData.length; i++) {
+            let xpath2;
+            if (xpathData[i].value.startsWith("//")) {
+              xpath2 = xpathData[i].value.substring(
+                xpathData[i].value.indexOf("//") + 2
+              );
+            } else {
+              xpath2 = xpathData[i].value; // No need to modify the value
+            }
+
+            return descendantExpression(
+              refExpectElement,
+              xpath2,
+              relation,
+              expElementDocmnt || docmt,
+              isIndex,
+              expCommonParentXpathElements,
+              step4,
+              refCommonParentXpathElementLength
+            );
+          }
+        }
+      }
+    }
+
+    for (const attrName of Array.from(refExpectElement[refExpectElement.length - 2]
+      .attributes)) {
+      if (
+        checkBlockedAttributes(attrName, refExpectElement[refExpectElement.length - 2], false)
+      ) {
+        let attrValue = attrName.nodeValue;
+        if (attrValue) {
+          attrValue = attrValue.replace("removePointers", "");
+          const combinationXpath = getCombinationXpath(
+            attrName,
+            refExpectElement[refExpectElement.length - 2]
+          );
+          if (combinationXpath) {
+            if (combinationXpath.startsWith("//")) {
+              nodeXpath2 = combinationXpath.substring(
+                combinationXpath.indexOf("//") + 2
+              );
+            } else {
+              nodeXpath2 = combinationXpath; // No need to modify the value
+            }
+
+            refCommonParentXpathElements[
+              refCommonParentXpathElements.length - 1
+            ] = nodeXpath2;
+
+            const refCommonParentXpath = refCommonParentXpathElements.join("[");
+            const refCommonParentXpathElementLength =
+              refCommonParentXpathElements.length - 1;
+
+            const step4 = refCommonParentXpath;
+
+            for (let i = 0; i < xpathData.length; i++) {
+              let xpath2;
+              if (xpathData[i].value.startsWith("//")) {
+                xpath2 = xpathData[i].value.substring(
+                  xpathData[i].value.indexOf("//") + 2
+                );
+              } else {
+                xpath2 = xpathData[i].value; // No need to modify the value
+              }
+
+              return descendantExpression(
+                refExpectElement,
+                xpath2,
+                relation,
+                expElementDocmnt || docmt,
+                isIndex,
+                expCommonParentXpathElements,
+                step4,
+                refCommonParentXpathElementLength
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const refCommonParentXpath = refCommonParentXpathElements.join("[");
+  const refCommonParentXpathElementLength =
+    refCommonParentXpathElements.length - 1;
+  const step4 = refCommonParentXpath;
+  const traverseXpath = getTraverseXpathExpression(
+    `${step4 +
+    (refCommonParentXpathElementLength
+      ? "]".repeat(refCommonParentXpathElementLength)
+      : "")
+    }`,
+    expCommonParentXpathElements.reverse(),
+    refExpectElement[refExpectElement.length - 1],
+    refExpectElement,
+    docmt,
+    relation,
+    isIndex
+  );
+  if (traverseXpath) {
+    return traverseXpath;
+  }
+};
+
+const getXpathRelationExpression = (
+  element1: HTMLElement | Element,
+  element2: HTMLElement | Element,
+  relation: string,
+  xpath1: any[],
+  xpath2: any[],
+  isIndex: any
+) => {
+  let xpaths1;
+  let xpaths2;
+  console.log('getXpathRelationExpression', relation)
+  const finalXpaths: { key: string; value: any }[] = [];
+
+  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: string | undefined = `//${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: HTMLElement | Element) => {
+  let xpaths1: {
+    key: string;
+    value: string;
+  }[] = [];
+
+  xpaths1 = parseDOM(element, element.ownerDocument, false, false);
+
+  if (!xpaths1?.length) {
+    xpaths1 = parseDOM(element, element.ownerDocument, true, false);
+    xpaths1 = xpaths1?.map((x) =>
+      x.value.charAt(0) == "(" &&
+        findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+        ? { key: "", value: removeParenthesis(x.value) }
+        : { key: "", value: x.value }
+    );
+  } else {
+    let xpaths = parseDOM(element, element.ownerDocument, true, false);
+    if (xpaths?.length) {
+      xpaths = xpaths?.map((x) =>
+        x.value.charAt(0) == "(" &&
+          findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+          ? { key: "", value: removeParenthesis(x.value) }
+          : { key: "", value: x.value }
+      );
+      xpaths1 = xpaths1.concat(xpaths);
+    }
+  }
+
+  if (!xpaths1?.length) {
+    xpaths1 = [
+      {
+        key: "",
+        value: getRelativeXPath(element, element.ownerDocument, false, false, Array.from(element.attributes)),
+      },
+    ];
+  }
+
+  if (!xpaths1?.length) {
+    xpaths1 = [
+      {
+        key: "",
+        value: getRelativeXPath(element, element.ownerDocument, true, false, Array.from(element.attributes)),
+      },
+    ];
+    xpaths1 = xpaths1?.map((x) =>
+      x.value.charAt(0) == "(" &&
+        findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
+        ? { key: "", value: removeParenthesis(x.value) }
+        : { key: "", value: x.value }
+    );
+  }
+
+  if (!xpaths1?.length) {
+    xpaths1 = getReferenceElementsXpath(element, element.ownerDocument, false);
+  } else {
+    const xpaths = getReferenceElementsXpath(
+      element,
+      element.ownerDocument,
+      false
+    );
+    if (xpaths?.length) {
+      xpaths1 = xpaths1.concat(xpaths);
+    }
+  }
+
+  const referenceXpathElement = getAbsoluteXPath(
+    element,
+    element.ownerDocument
+  );
+  xpaths1 = xpaths1.filter((x) => x.value !== referenceXpathElement);
+
+  xpaths1.push({
+    key: "absolute xpath",
+    value: referenceXpathElement.slice(1),
+  });
+
+  return xpaths1;
+};
+
+const getTraverseXpathExpression = (
+  xpathe1: string,
+  absoluteXpathElements: any[],
+  element2: HTMLElement | Element,
+  refExpectElement: Array<HTMLElement | Element>,
+  docmt: Node,
+  relation: string,
+  isIndex: any
+) => {
+  let finalExpectedElementXpath: string | undefined
+  if (multiElementReferenceMode) {
+    const xpath2 = absoluteXpathElements.join("/");
+    finalExpectedElementXpath = `//${xpathe1}/${relation}::${replaceActualAttributes(
+      xpath2,
+      element2
+    )}`;
+    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),
+            },
+          ];
+        }
+      }
+    }
+  } else {
+    for (let x = 1; x <= absoluteXpathElements.length; x++) {
+      const xpath2 = absoluteXpathElements
+        .slice(absoluteXpathElements.length - x, absoluteXpathElements.length)
+        .join("/");
+      finalExpectedElementXpath = `//${xpathe1}/${relation}::${replaceActualAttributes(
+        xpath2,
+        element2
+      )}`;
+      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,
+};
+
+export default referenceXpath;