ff-dom 1.0.17 → 1.0.18-beta.1

package/dist/types/browser/browser/xpath.d.ts

@@ -0,0 +1,110 @@
+export declare const createXPathAPI: () => {
+    xpath: {
+        parseDOM: (element: HTMLElement | Element, doc: Document, isIndex: boolean, isTarget: boolean) => {
+            key: string;
+            value: string;
+        }[];
+        getTextXPath: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+        getUniqueClassName: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+        attributesBasedXPath: (attr: Attr, targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+        addAllXPathAttributes: (attributes: Attr[], targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => void;
+        addRelativeXpaths: (targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, attribute: Attr[]) => {
+            key: string;
+            value: string;
+        }[] | undefined;
+        getXPathUsingAttributeAndText: (attributes: Attr[], targetElemt: HTMLElement | Element, docmt: Document, isTarget: boolean) => string | undefined;
+        getSiblingRelativeXPath: (domNode: HTMLElement | Element, docmt: Document, isTarget: boolean, nodeXpath: string) => null | undefined;
+        getChildRelativeXpath: (domNode: HTMLElement | Element, docmt: Document, node: HTMLElement | Element) => string | null;
+        getParentRelativeXpath: (domNode: HTMLElement, docmt: Document, node: HTMLElement | Element, isTarget: boolean) => any;
+        getUniqueParentXpath: (domNode: HTMLElement, docmt: Document, node: HTMLElement | Element, isTarget: boolean, nodeXpath: string, isIndex: boolean) => any;
+        checkRelativeXpathRelation: (nodeXpath1: string, nodeXpath2: string, targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, relationType: string) => string | null;
+    };
+    referenceXpaths: {
+        findRelativeXpath: (element1: HTMLElement | Element, element2: HTMLElement | Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: any) => any[] | undefined;
+        getDescendantXpath: (refExpectElement: Array<HTMLElement | Element>, docmt: Document, xpaths1: {
+            key: string;
+            value: string;
+        }[], xpaths2: {
+            key: string;
+            value: string;
+        }[], relation: "descendant" | "descedant-or-self", isIndex: boolean) => {
+            key: string;
+            value: string;
+        }[] | undefined;
+        getXpathRelationExpression: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: string, xpath1: any[], xpath2: any[], isIndex: any) => {
+            key: string;
+            value: any;
+        }[];
+        getTraverseXpathExpression: (xpathe1: string, absoluteXpathElements: any[], element2: HTMLElement | Element, refExpectElement: Array<HTMLElement | Element>, docmt: Node, relation: string, isIndex: any) => {
+            key: string;
+            value: string;
+        }[] | undefined;
+        getReferenceElementXpath: (element: HTMLElement | Element) => {
+            key: string;
+            value: string;
+        }[];
+    };
+    xpathUtils: {
+        parseXml: typeof import("../utils/xpathHelpers.ts").parseXml;
+        getReferenceElementsXpath: (domNode: HTMLElement | Element, docmt: Document, isTarget: boolean) => {
+            key: string;
+            value: string;
+        }[];
+        getAbsoluteXPath: (domNode: HTMLElement | Element | null, docmt: Document) => string;
+        getRelativeXPath: (domNode: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean | undefined, attributesArray: Attr[]) => any;
+        getCombinationXpath: (attribute: Attr, domNode: HTMLElement | Element) => string | undefined;
+        getAttributeCombinationXpath: (domNode: HTMLElement | Element, docmt: Document, uniqueAttributes: Attr[], isTarget: boolean) => string | undefined;
+        getElementFromXpath: (xpath: string, docmt: Node, multi?: boolean) => Node | XPathResult | null;
+        isSvg: (element: HTMLElement | Element) => element is SVGElement;
+        findXpathWithIndex: (val: string, node: HTMLElement | Element, docmt: Node, count: number) => string | undefined;
+        isNumberExist: (str: string) => boolean;
+        getTextContent: (targetElement: HTMLElement | Element) => string;
+        getCountOfXPath: (xpath: string, element: HTMLElement | Element, docmt: Node) => number;
+        normalizeXPath: (xpath: string) => string;
+        getShadowRoot: (a: HTMLElement | Element) => Element | null;
+        escapeCharacters: (text: string) => string;
+        removeParenthesis: (xpath: string) => string;
+        checkBlockedAttributes: (attribute: {
+            name: string;
+            value: string;
+        }, targetElement: HTMLElement | Element, isTarget: boolean) => boolean;
+        getRelationship: (a: HTMLElement, b: HTMLElement) => "" | "preceding" | "following" | "ancestor" | "descendant" | "self";
+        findMatchingParenthesis: (text: string, openPos: number) => number;
+        deleteGarbageFromInnerText: (a: string) => string;
+        replaceTempAttributes: (str: string) => string;
+        createObserver: (addedNodeCallBack: Function) => void;
+        startObserver: (target: Node, options: MutationObserverInit | undefined) => void;
+        stopObserver: () => void;
+        modifiedElementAttributes: {
+            url: string | null;
+            attributeName: string | null;
+            element: HTMLElement | Element;
+            doc: Document;
+        }[];
+    };
+    getElementsFromHTML: (record: import("../types/locator.ts").ElementRecord, docmt: Document) => {
+        [key: string]: any;
+        id?: string | null;
+        className?: string | null;
+        xpathByText?: string | null;
+        xpathById?: string | null;
+        xpathByClass?: string | null;
+        xpathAbsolute?: string | null;
+        xpathByName?: string | null;
+        xpathByPlaceholder?: string | null;
+        xpathByType?: string | null;
+        visibleText?: string | null;
+        relativeXpath?: string | null;
+    } | null;
+    cssSelectors: {
+        parseCssSelectors: (el: HTMLElement | Element, docmt: Document) => {
+            key: string;
+            value: string;
+        }[];
+        getIdCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+        getNameCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+        getClassCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+        getAbsoluteCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+    };
+};
+export default createXPathAPI;

package/dist/types/browser/types/locator.d.ts

@@ -0,0 +1,26 @@
+export interface Locator {
+    name: string;
+    type: string;
+    value: string;
+    reference: string;
+    status: string;
+    isRecorded: string;
+    isSelfHealed?: string;
+}
+export interface ElementRecord {
+    name: string;
+    desc: string;
+    type: string;
+    locators: Locator[];
+    isShared: string;
+    projectId: string;
+    projectType: string;
+    isRecorded: string;
+    folder: string;
+    parentId: string;
+    parentName: string;
+    platform: string;
+    licenseId: string;
+    licenseType: string;
+    userId: string;
+}

package/dist/types/browser/utils/cssSelector.d.ts

@@ -0,0 +1,18 @@
+export declare const parseCssSelectors: (el: HTMLElement | Element, docmt: Document) => {
+    key: string;
+    value: string;
+}[];
+export declare const getIdCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+export declare const getNameCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+export declare const getClassCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+export declare const getAbsoluteCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+export declare const cssSelectors: {
+    parseCssSelectors: (el: HTMLElement | Element, docmt: Document) => {
+        key: string;
+        value: string;
+    }[];
+    getIdCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+    getNameCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+    getClassCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+    getAbsoluteCssPath: (el: HTMLElement | Element, docmt: Document) => string | undefined;
+};

package/dist/types/browser/utils/getElementsFromHTML.d.ts

@@ -0,0 +1,17 @@
+import { ElementRecord } from "../types/locator.ts";
+type ElementDetails = {
+    id?: string | null;
+    className?: string | null;
+    xpathByText?: string | null;
+    xpathById?: string | null;
+    xpathByClass?: string | null;
+    xpathAbsolute?: string | null;
+    xpathByName?: string | null;
+    xpathByPlaceholder?: string | null;
+    xpathByType?: string | null;
+    visibleText?: string | null;
+    relativeXpath?: string | null;
+    [key: string]: any;
+};
+declare const getElementsFromHTML: (record: ElementRecord, docmt: Document) => ElementDetails | null;
+export { getElementsFromHTML };

package/dist/types/browser/utils/referenceXpath.d.ts

@@ -0,0 +1,27 @@
+export declare const findRelativeXpath: (element1: HTMLElement | Element, element2: HTMLElement | Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: any) => any[] | undefined;
+declare const referenceXpath: {
+    findRelativeXpath: (element1: HTMLElement | Element, element2: HTMLElement | Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: any) => any[] | undefined;
+    getDescendantXpath: (refExpectElement: Array<HTMLElement | Element>, docmt: Document, xpaths1: {
+        key: string;
+        value: string;
+    }[], xpaths2: {
+        key: string;
+        value: string;
+    }[], relation: "descendant" | "descedant-or-self", isIndex: boolean) => {
+        key: string;
+        value: string;
+    }[] | undefined;
+    getXpathRelationExpression: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: string, xpath1: any[], xpath2: any[], isIndex: any) => {
+        key: string;
+        value: any;
+    }[];
+    getTraverseXpathExpression: (xpathe1: string, absoluteXpathElements: any[], element2: HTMLElement | Element, refExpectElement: Array<HTMLElement | Element>, docmt: Node, relation: string, isIndex: any) => {
+        key: string;
+        value: string;
+    }[] | undefined;
+    getReferenceElementXpath: (element: HTMLElement | Element) => {
+        key: string;
+        value: string;
+    }[];
+};
+export default referenceXpath;

package/dist/types/browser/utils/xpath.d.ts

@@ -0,0 +1,29 @@
+declare function getXPathUsingAttributeAndText(attributes: Attr[], targetElemt: HTMLElement | Element, docmt: Document, isTarget: boolean): string | undefined;
+export declare const attributesBasedXPath: (attr: Attr, targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+export declare const getUniqueClassName: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+export declare const getTextXPath: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+export declare const parseDOM: (element: HTMLElement | Element, doc: Document, isIndex: boolean, isTarget: boolean) => {
+    key: string;
+    value: string;
+}[];
+declare const xpath: {
+    parseDOM: (element: HTMLElement | Element, doc: Document, isIndex: boolean, isTarget: boolean) => {
+        key: string;
+        value: string;
+    }[];
+    getTextXPath: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+    getUniqueClassName: (element: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+    attributesBasedXPath: (attr: Attr, targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => string | undefined;
+    addAllXPathAttributes: (attributes: Attr[], targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean) => void;
+    addRelativeXpaths: (targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean, attribute: Attr[]) => {
+        key: string;
+        value: string;
+    }[] | undefined;
+    getXPathUsingAttributeAndText: typeof getXPathUsingAttributeAndText;
+    getSiblingRelativeXPath: (domNode: HTMLElement | Element, docmt: Document, isTarget: boolean, nodeXpath: string) => null | undefined;
+    getChildRelativeXpath: (domNode: HTMLElement | Element, docmt: Document, node: HTMLElement | Element) => string | null;
+    getParentRelativeXpath: (domNode: HTMLElement, docmt: Document, node: HTMLElement | Element, isTarget: boolean) => any;
+    getUniqueParentXpath: (domNode: HTMLElement, docmt: Document, node: HTMLElement | Element, isTarget: boolean, nodeXpath: string, isIndex: boolean) => any;
+    checkRelativeXpathRelation: (nodeXpath1: string, nodeXpath2: string, targetElemt: HTMLElement | Element, docmt: Document, isIndex: boolean, relationType: string) => string | null;
+};
+export default xpath;

package/dist/types/browser/utils/xpathHelpers.d.ts

@@ -0,0 +1,88 @@
+export declare const reWhiteSpace: RegExp;
+export declare let modifiedElementAttributes: {
+    url: string | null;
+    attributeName: string | null;
+    element: HTMLElement | Element;
+    doc: Document;
+}[];
+export declare const createObserver: (addedNodeCallBack: Function) => void;
+export declare const startObserver: (target: Node, options: MutationObserverInit | undefined) => void;
+export declare const stopObserver: () => void;
+export declare const isNumberExist: (str: string) => boolean;
+export declare const buildPattern: (pattern: string, isSvg: boolean, tagName: string) => string;
+export declare const getTextContent: (targetElement: HTMLElement | Element) => string;
+export declare const getFilteredText: (element: Node) => string;
+export declare const getCountOfXPath: (xpath: string, element: HTMLElement | Element, docmt: Node) => number;
+export declare const escapeCharacters: (text: string) => string;
+export declare const removeParenthesis: (xpath: string) => string;
+export declare const findXpathWithIndex: (val: string, node: HTMLElement | Element, docmt: Node, count: number) => string | undefined;
+export declare const replaceWhiteSpaces: (str: string) => string;
+export declare const getShadowRoot: (a: HTMLElement | Element) => Element | null;
+export declare const checkBlockedAttributes: (attribute: {
+    name: string;
+    value: string;
+}, targetElement: HTMLElement | Element, isTarget: boolean) => boolean;
+export declare const getRelationship: (a: HTMLElement, b: HTMLElement) => "" | "preceding" | "following" | "ancestor" | "descendant" | "self";
+export declare const findRoot: (node: Node) => Node;
+export declare const isSvg: (element: HTMLElement | Element) => element is SVGElement;
+export declare const replaceTempAttributes: (str: string) => string;
+export declare const getPropertyXPath: (element: HTMLElement | Element, docmt: Document, prop: string, value: string, isIndex: boolean, isTarget: boolean) => string | undefined;
+export declare const getAbsoluteXPath: (domNode: HTMLElement | Element | null, docmt: Document) => string;
+export declare const getRelativeXPath: (domNode: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean | undefined, attributesArray: Attr[]) => any;
+export declare const getCombinationXpath: (attribute: Attr, domNode: HTMLElement | Element) => string | undefined;
+export declare const getAttributeCombinationXpath: (domNode: HTMLElement | Element, docmt: Document, uniqueAttributes: Attr[], isTarget: boolean) => string | undefined;
+export declare const intermediateXpathStep: (targetElemt: HTMLElement | Element, attr: {
+    name: string;
+    value: string;
+}, isTarget: boolean) => string;
+export declare const getFilteredTextXPath: (node: HTMLElement | Element, docmt: Document) => string;
+export declare const getTextXpathFunction: (domNode: HTMLElement | Element) => string | undefined;
+export declare const getXpathString: (node: HTMLElement | Element, attrName: string, attrValue: string) => string;
+export declare const replaceActualAttributes: (str: string, element: {
+    attributes: any;
+}) => string;
+export declare const getReferenceElementsXpath: (domNode: HTMLElement | Element, docmt: Document, isTarget: boolean) => {
+    key: string;
+    value: string;
+}[];
+export declare function parseXml(xmlStr: string): Document | null;
+export declare const normalizeXPath: (xpath: string) => string;
+export declare const findMatchingParenthesis: (text: string, openPos: number) => number;
+export declare const xpathUtils: {
+    parseXml: typeof parseXml;
+    getReferenceElementsXpath: (domNode: HTMLElement | Element, docmt: Document, isTarget: boolean) => {
+        key: string;
+        value: string;
+    }[];
+    getAbsoluteXPath: (domNode: HTMLElement | Element | null, docmt: Document) => string;
+    getRelativeXPath: (domNode: HTMLElement | Element, docmt: Document, isIndex: boolean, isTarget: boolean | undefined, attributesArray: Attr[]) => any;
+    getCombinationXpath: (attribute: Attr, domNode: HTMLElement | Element) => string | undefined;
+    getAttributeCombinationXpath: (domNode: HTMLElement | Element, docmt: Document, uniqueAttributes: Attr[], isTarget: boolean) => string | undefined;
+    getElementFromXpath: (xpath: string, docmt: Node, multi?: boolean) => Node | XPathResult | null;
+    isSvg: (element: HTMLElement | Element) => element is SVGElement;
+    findXpathWithIndex: (val: string, node: HTMLElement | Element, docmt: Node, count: number) => string | undefined;
+    isNumberExist: (str: string) => boolean;
+    getTextContent: (targetElement: HTMLElement | Element) => string;
+    getCountOfXPath: (xpath: string, element: HTMLElement | Element, docmt: Node) => number;
+    normalizeXPath: (xpath: string) => string;
+    getShadowRoot: (a: HTMLElement | Element) => Element | null;
+    escapeCharacters: (text: string) => string;
+    removeParenthesis: (xpath: string) => string;
+    checkBlockedAttributes: (attribute: {
+        name: string;
+        value: string;
+    }, targetElement: HTMLElement | Element, isTarget: boolean) => boolean;
+    getRelationship: (a: HTMLElement, b: HTMLElement) => "" | "preceding" | "following" | "ancestor" | "descendant" | "self";
+    findMatchingParenthesis: (text: string, openPos: number) => number;
+    deleteGarbageFromInnerText: (a: string) => string;
+    replaceTempAttributes: (str: string) => string;
+    createObserver: (addedNodeCallBack: Function) => void;
+    startObserver: (target: Node, options: MutationObserverInit | undefined) => void;
+    stopObserver: () => void;
+    modifiedElementAttributes: {
+        url: string | null;
+        attributeName: string | null;
+        element: HTMLElement | Element;
+        doc: Document;
+    }[];
+};

package/dist/types/node/node/xpath.d.ts

@@ -0,0 +1,8 @@
+import { ElementRecord } from "../types/locator";
+declare function createXPathAPI(): Promise<{
+    fromHTML: (html: string) => Promise<{
+        autoHeal: (data: ElementRecord, htmlString: string) => Promise<void>;
+    }>;
+    browser: any;
+}>;
+export default createXPathAPI;

package/dist/types/node/types/locator.d.ts

@@ -0,0 +1,26 @@
+export interface Locator {
+    name: string;
+    type: string;
+    value: string;
+    reference: string;
+    status: string;
+    isRecorded: string;
+    isSelfHealed?: string;
+}
+export interface ElementRecord {
+    name: string;
+    desc: string;
+    type: string;
+    locators: Locator[];
+    isShared: string;
+    projectId: string;
+    projectType: string;
+    isRecorded: string;
+    folder: string;
+    parentId: string;
+    parentName: string;
+    platform: string;
+    licenseId: string;
+    licenseType: string;
+    userId: string;
+}

package/dist/xpath.mjs

@@ -0,0 +1,63 @@
+import { fileURLToPath } from 'url';
+import path, { join } from 'path';
+import { readFileSync } from 'fs';
+
+const _filename = fileURLToPath(import.meta.url);
+const _dirname = path.dirname(_filename);
+let puppeteer;
+const injectScriptPath = join(_dirname, "index.cdn.js");
+const injectScript = readFileSync(injectScriptPath, "utf-8");
+async function createXPathAPI() {
+    puppeteer = await import('puppeteer');
+    let browser = await puppeteer.launch({ headless: true });
+    let page = await browser.newPage();
+    const fromHTML = async (html) => {
+        await page?.setContent(html);
+        await page?.addScriptTag({ content: injectScript });
+        page?.on("console", async (msg) => {
+            const type = msg.type();
+            const txt = msg.text();
+            const args = msg.args();
+            if (!args || args.length === 0) {
+                console.log(`[Browser:${type}]`, txt);
+                return;
+            }
+            for (let i = 0; i < args.length; i++) {
+                try {
+                    const arg = args[i];
+                    const obj = arg.remoteObject();
+                    console.log(obj);
+                    if (obj.value !== undefined) {
+                        console.log(`[Browser:${type}]`, obj.value);
+                    }
+                    else {
+                        const value = await arg.jsonValue().catch(() => txt);
+                        console.log(`[Browser:${type}]`, value);
+                    }
+                }
+                catch (err) {
+                    console.log(`[Browser:${type}]`, txt);
+                }
+            }
+        });
+        page?.on("pageerror", (msg) => {
+            console.log("error", msg);
+        });
+        return {
+            autoHeal: async (data, htmlString) => {
+                await page?.evaluate((datum, html) => {
+                    // let docmt = (window as any).XpathLib.parseXml(html);
+                    // return (window as any).XpathLib.getElementsFromHTML(datum, docmt);
+                    // @ts-ignore
+                    let xpathAPI = window.XpathLib.createXPathAPI();
+                    let docmt = xpathAPI.xpathUtils.parseXml(html);
+                    return xpathAPI.getElementsFromHTML(datum, docmt);
+                }, data, htmlString);
+            },
+        };
+    };
+    return { fromHTML, browser };
+}
+
+export { createXPathAPI as default };
+//# sourceMappingURL=xpath.mjs.map

package/dist/xpath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"xpath.mjs","sources":["../src/node/xpath.ts"],"sourcesContent":["import { fileURLToPath } from \"url\";\r\nimport path, { join } from \"path\";\r\nimport { readFileSync } from \"fs\";\r\nimport { ElementRecord } from \"../types/locator\";\r\n\r\nconst _filename = fileURLToPath(import.meta.url);\r\nconst _dirname = path.dirname(_filename);\r\n\r\nlet puppeteer: any;\r\n\r\nconst injectScriptPath = join(_dirname, \"index.cdn.js\");\r\nconst injectScript = readFileSync(injectScriptPath, \"utf-8\");\r\n\r\nasync function createXPathAPI() {\r\n  puppeteer = await import('puppeteer');\r\n\r\n  let browser = await puppeteer.launch({ headless: true });\r\n  let page = await browser.newPage();\r\n\r\n  const fromHTML = async (html: string) => {\r\n    await page?.setContent(html);\r\n    await page?.addScriptTag({ content: injectScript });\r\n\r\n    page?.on(\r\n      \"console\",\r\n      async (msg: { type: () => any; text: () => any; args: () => any }) => {\r\n        const type = msg.type();\r\n        const txt = msg.text();\r\n\r\n        const args = msg.args();\r\n        if (!args || args.length === 0) {\r\n          console.log(`[Browser:${type}]`, txt);\r\n          return;\r\n        }\r\n\r\n        for (let i = 0; i < args.length; i++) {\r\n          try {\r\n            const arg = args[i];\r\n            const obj = arg.remoteObject();\r\n\r\n            console.log(obj);\r\n\r\n            if (obj.value !== undefined) {\r\n              console.log(`[Browser:${type}]`, obj.value);\r\n            } else {\r\n              const value = await arg.jsonValue().catch(() => txt);\r\n              console.log(`[Browser:${type}]`, value);\r\n            }\r\n          } catch (err) {\r\n            console.log(`[Browser:${type}]`, txt);\r\n          }\r\n        }\r\n      }\r\n    );\r\n\r\n    page?.on(\"pageerror\", (msg: any) => {\r\n      console.log(\"error\", msg);\r\n    });\r\n\r\n    return {\r\n      autoHeal: async (data: ElementRecord, htmlString: string) => {\r\n        await page?.evaluate((datum: ElementRecord, html: string) => {\r\n          // let docmt = (window as any).XpathLib.parseXml(html);\r\n          // return (window as any).XpathLib.getElementsFromHTML(datum, docmt);\r\n          // @ts-ignore\r\n          let xpathAPI = window.XpathLib.createXPathAPI();\r\n          let docmt = xpathAPI.xpathUtils.parseXml(html);\r\n          return xpathAPI.getElementsFromHTML(datum, docmt);\r\n        }, data, htmlString);\r\n      },\r\n    };\r\n  };\r\n\r\n  return { fromHTML, browser };\r\n}\r\n\r\nexport default createXPathAPI;\r\n"],"names":[],"mappings":";;;;AAKA,MAAM,SAAS,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;AAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;AAExC,IAAI,SAAc;AAElB,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC;AACvD,MAAM,YAAY,GAAG,YAAY,CAAC,gBAAgB,EAAE,OAAO,CAAC;AAE5D,eAAe,cAAc,GAAA;AAC3B,IAAA,SAAS,GAAG,MAAM,OAAO,WAAW,CAAC;AAErC,IAAA,IAAI,OAAO,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AACxD,IAAA,IAAI,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,EAAE;AAElC,IAAA,MAAM,QAAQ,GAAG,OAAO,IAAY,KAAI;AACtC,QAAA,MAAM,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC;QAC5B,MAAM,IAAI,EAAE,YAAY,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC;QAEnD,IAAI,EAAE,EAAE,CACN,SAAS,EACT,OAAO,GAA0D,KAAI;AACnE,YAAA,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,EAAE;AACvB,YAAA,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,EAAE;AAEtB,YAAA,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,EAAE;YACvB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC9B,OAAO,CAAC,GAAG,CAAC,CAAA,SAAA,EAAY,IAAI,CAAA,CAAA,CAAG,EAAE,GAAG,CAAC;gBACrC;YACF;AAEA,YAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACpC,gBAAA,IAAI;AACF,oBAAA,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC;AACnB,oBAAA,MAAM,GAAG,GAAG,GAAG,CAAC,YAAY,EAAE;AAE9B,oBAAA,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;AAEhB,oBAAA,IAAI,GAAG,CAAC,KAAK,KAAK,SAAS,EAAE;wBAC3B,OAAO,CAAC,GAAG,CAAC,CAAA,SAAA,EAAY,IAAI,CAAA,CAAA,CAAG,EAAE,GAAG,CAAC,KAAK,CAAC;oBAC7C;yBAAO;AACL,wBAAA,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;wBACpD,OAAO,CAAC,GAAG,CAAC,CAAA,SAAA,EAAY,IAAI,CAAA,CAAA,CAAG,EAAE,KAAK,CAAC;oBACzC;gBACF;gBAAE,OAAO,GAAG,EAAE;oBACZ,OAAO,CAAC,GAAG,CAAC,CAAA,SAAA,EAAY,IAAI,CAAA,CAAA,CAAG,EAAE,GAAG,CAAC;gBACvC;YACF;AACF,QAAA,CAAC,CACF;QAED,IAAI,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,GAAQ,KAAI;AACjC,YAAA,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC;AAC3B,QAAA,CAAC,CAAC;QAEF,OAAO;AACL,YAAA,QAAQ,EAAE,OAAO,IAAmB,EAAE,UAAkB,KAAI;gBAC1D,MAAM,IAAI,EAAE,QAAQ,CAAC,CAAC,KAAoB,EAAE,IAAY,KAAI;;;;oBAI1D,IAAI,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,cAAc,EAAE;oBAC/C,IAAI,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;oBAC9C,OAAO,QAAQ,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC;AACnD,gBAAA,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC;YACtB,CAAC;SACF;AACH,IAAA,CAAC;AAED,IAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE;AAC9B;;;;"}

package/package.json

@@ -1,21 +1,71 @@
 {
     "name": "ff-dom",
-    "version": "1.0.17",
+    "version": "1.0.18-beta.1",
     "description": "",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
+    "type": "module",
+    "files": [
+        "dist",
+        "src",
+        "package.json",
+        "README.md",
+        "tsconfig.json",
+        "tsconfig.node.json",
+        "tsconfig.browser.json"
+    ],
+    "main": "dist/index.browser.cjs",
+    "module": "dist/index.browser.js",
+    "types": "dist/types/browser/browser/.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/types/browser/browser/xpath.d.ts",
+            "import": "./dist/index.browser.js",
+            "default": "./dist/index.browser.js",
+            "require": "./dist/index.browser.cjs"
+        },
+        "./node": {
+            "import": "./dist/xpath.mjs",
+            "default": "./dist/xpath.mjs",
+            "types": "./dist/types/node/xpath.d.ts"
+        }
+    },
+    "typesVersions": {
+        "*": {
+            "*": [
+                "dist/types/browser/xpath.d.ts"
+            ],
+            "node": [
+                "dist/types/node/xpath.d.ts"
+            ]
+        }
+    },
     "scripts": {
-        "build": "tsc",
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "lint": "eslint --fix",
+        "build": "rimraf dist && npm run types && rollup -c",
+        "types:node": "tsc -p tsconfig.node.json --emitDeclarationOnly --outDir dist/types/node",
+        "types:browser": "tsc -p tsconfig.browser.json --emitDeclarationOnly --outDir dist/types/browser",
+        "types": "npm run types:node && npm run types:browser",
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "test:node": "node test/node.spec.js",
+        "test:browser": "start test/browser.spec.js"
     },
     "keywords": [],
     "author": "",
     "license": "ISC",
     "dependencies": {
-      "jsdom": "^25.0.1"
+        "puppeteer": "^24.30.0"
     },
     "devDependencies": {
-        "@types/jsdom": "^21.1.7",
-        "typescript": "^5.6.3"
+        "@rollup/plugin-commonjs": "^28.0.9",
+        "@rollup/plugin-dynamic-import-vars": "^2.1.5",
+        "@rollup/plugin-node-resolve": "^16.0.3",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^12.1.4",
+        "@typescript-eslint/eslint-plugin": "^8.46.2",
+        "@typescript-eslint/parser": "^8.46.2",
+        "eslint": "^9.38.0",
+        "rimraf": "^6.1.0",
+        "rollup": "^4.52.4",
+        "tslib": "^2.8.1",
+        "typescript": "^5.9.3"
     }
 }

package/src/browser/xpath.ts

@@ -0,0 +1,15 @@
+import xpath from '../utils/xpath.ts';
+import referenceXpaths from '../utils/referenceXpath.ts';
+import { xpathUtils } from '../utils/xpathHelpers.ts';
+import { getElementsFromHTML } from '../utils/getElementsFromHTML.ts';
+import { cssSelectors } from '../utils/cssSelector.ts';
+
+export const createXPathAPI = () => ({
+  xpath,
+  referenceXpaths,
+  xpathUtils,
+  getElementsFromHTML,
+  cssSelectors
+});
+
+export default createXPathAPI;

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './node/xpath.ts';
+export * from './browser/xpath.ts';

package/src/node/xpath.d.ts

@@ -0,0 +1,9 @@
+import createXPathAPI from '../browser/xpath';
+
+declare global {
+    interface window {
+        XpathLib: typeof createXPathAPI
+    }
+}
+
+declare var puppeteer: any;

package/src/node/xpath.ts

@@ -0,0 +1,75 @@
+import { fileURLToPath } from "url";
+import path, { join } from "path";
+import { readFileSync } from "fs";
+import { ElementRecord } from "../types/locator";
+
+const _filename = fileURLToPath(import.meta.url);
+const _dirname = path.dirname(_filename);
+
+let puppeteer: any;
+
+const injectScriptPath = join(_dirname, "index.cdn.js");
+const injectScript = readFileSync(injectScriptPath, "utf-8");
+
+async function createXPathAPI() {
+  puppeteer = await import('puppeteer');
+
+  let browser = await puppeteer.launch({ headless: true });
+  let page = await browser.newPage();
+
+  const fromHTML = async (html: string) => {
+    await page?.setContent(html);
+    await page?.addScriptTag({ content: injectScript });
+
+    page?.on(
+      "console",
+      async (msg: { type: () => any; text: () => any; args: () => any }) => {
+        const type = msg.type();
+        const txt = msg.text();
+
+        const args = msg.args();
+        if (!args || args.length === 0) {
+          console.log(`[Browser:${type}]`, txt);
+          return;
+        }
+
+        for (let i = 0; i < args.length; i++) {
+          try {
+            const arg = args[i];
+            const obj = arg.remoteObject();
+
+            console.log(obj);
+
+            if (obj.value !== undefined) {
+              console.log(`[Browser:${type}]`, obj.value);
+            } else {
+              const value = await arg.jsonValue().catch(() => txt);
+              console.log(`[Browser:${type}]`, value);
+            }
+          } catch (err) {
+            console.log(`[Browser:${type}]`, txt);
+          }
+        }
+      }
+    );
+
+    page?.on("pageerror", (msg: any) => {
+      console.log("error", msg);
+    });
+
+    return {
+      autoHeal: async (data: ElementRecord, htmlString: string) => {
+        await page?.evaluate((datum: ElementRecord, html: string) => {
+          // @ts-ignore
+          let xpathAPI = window.XpathLib.createXPathAPI();
+          let docmt = xpathAPI.xpathUtils.parseXml(html);
+          return xpathAPI.getElementsFromHTML(datum, docmt);
+        }, data, htmlString);
+      },
+    };
+  };
+
+  return { fromHTML, browser };
+}
+
+export default createXPathAPI;

package/src/types/locator.ts

@@ -0,0 +1,27 @@
+export interface Locator {
+  name: string;
+  type: string;
+  value: string;
+  reference: string;
+  status: string;
+  isRecorded: string;
+  isSelfHealed?: string;
+}
+
+export interface ElementRecord {
+  name: string;
+  desc: string;
+  type: string;
+  locators: Locator[];
+  isShared: string;
+  projectId: string;
+  projectType: string;
+  isRecorded: string;
+  folder: string;
+  parentId: string;
+  parentName: string;
+  platform: string;
+  licenseId: string;
+  licenseType: string;
+  userId: string
+}